partie.cpp

#include "partie.h"
#include "plateau.h"
#include "joueur.h"
#include "mainwindow.h"

#include "insecte.h"
#include "usineinsecte.h"
#include "insecte.h"
#include "ia_random.h"

#include "graphicspartie.h"

#include <stdexcept>
#include <iostream>

/**
 * @file partie.cpp
 * @brief Implémentation de la classe Partie.
 * 
 * La classe Partie gère la logique principale du jeu, y compris les joueurs,
 * le plateau, et les actions comme les déplacements, placements, et annulations.
 */

/**
 * @brief Constructeur de la classe Partie.
 * 
 * Initialise une partie avec les joueurs et leur configuration.
 * 
 * @param joueur1_pseudo Nom du joueur 1.
 * @param joueur2_pseudo Nom du joueur 2.
 * @param nb_retours Nombre de retours en arrière autorisés pour chaque joueur.
 */
Partie::Partie(std::string joueur1_pseudo, std::string joueur2_pseudo , unsigned int nb_retours, std::vector<std::string> insectes, bool presence_ia)
    : joueur1(Qt::red, joueur1_pseudo, nb_retours, insectes),
    joueur2(Qt::yellow, joueur2_pseudo, nb_retours, insectes),
    nb_retours_possibles(nb_retours),
    presence_ia(presence_ia)
{
    if(presence_ia){
        ia = new IA_random(this, &joueur2);
    }

    plateau = new Plateau(this);
    // setup_test();

    actions = {};
}

Partie::Partie(std::string joueur1_pseudo, std::string joueur2_pseudo, unsigned int nb_retours, std::vector<std::string> insectes, std::vector<Action> actions, bool presence_ia)
    : joueur1(Qt::red, joueur1_pseudo, nb_retours, insectes),
    joueur2(Qt::yellow, joueur2_pseudo, nb_retours, insectes),
    nb_retours_possibles(nb_retours)
{
    if(presence_ia){
        ia = new IA_random(this, &joueur2);
    }
    plateau = new Plateau(this);

    this->actions = {};

    for (auto action : actions)
    {
        jouer_tour(action);
    }
}

/**
 * @brief Destructeur de la classe Partie.
 * 
 * Libère les ressources allouées, notamment le plateau.
 */
Partie::~Partie()
{
    delete plateau;
    delete ia;
}

/**
 * @brief Joue un tour en mode CLI.
 * 
 * Lit et exécute une commande utilisateur en mode terminal (CLI).
 * 
 * @param cmd Commande utilisateur.
 * @return std::string Résultat de l'exécution de la commande.
 */
std::string Partie::jouer_tour_cli(std::string cmd)
{
    // Logique détaillée pour interpréter et exécuter les commandes "undo", "place", "move".
    // Suppression des doublons ici pour concision, la logique reste inchangée.
    // Voir le code d'origine pour les détails des blocs conditionnels.

    std::string token;

    lire_prochain_token(cmd, token);

    if (token == "undo")
    {
        lire_prochain_token(cmd, token);
        if (nb_tours < 2)
        {
            return "Vous ne pouvez pas encore annuler d'action.";
        }

        else
            annuler_action(tour);
    }

    if (token == "place")
    {
        lire_prochain_token(cmd, token);

        Type::Type type = Type::str_to_type(token);
        if (type != Type::Type::NONE)
        {
            QPoint p;

            lire_prochain_token(cmd, token);

            try
            {
                p.rx() = std::stoi(token);

                lire_prochain_token(cmd, token);

                try
                {
                    p.ry() = std::stoi(token);


                    Case* c = plateau->get_case(p);
                    if (c)
                    {
                        if (!jouer_tour(Action{QPoint(c->get_position()), type}))
                        {
                            return "Placement invalide";
                        }

                    }
                    else
                    {
                        return "Case [" + std::to_string(p.x()) + "; " + std::to_string(p.y()) + "] non existante";
                    }
                }
                catch (const std::invalid_argument& e)
                {
                    return "Coordonees invalides";
                }
            }
            catch (const std::invalid_argument& e)
            {
                return "Coordonees invalides";
            }
        }
    }
    else if (token == "move")
    {
        QPoint p;

        lire_prochain_token(cmd, token);
        try
        {
            p.rx() = std::stoi(token);

            lire_prochain_token(cmd, token);
            try
            {
                p.ry() = std::stoi(token);


                Case* c = plateau->get_case(p);
                if (c)
                {

                    QPoint p2;

                    lire_prochain_token(cmd, token);
                    try
                    {
                        p2.rx() = std::stoi(token);


                        lire_prochain_token(cmd, token);
                        try
                        {
                            p2.ry() = std::stoi(token);


                            Case* c2 = plateau->get_case(p2);
                            if (c2)
                            {
                                if (c->get_joueur() == tour)
                                {
                                    std::vector<Case*> move_possibles;
                                    c->get_pion()->get_moves_possibles(move_possibles);
                                    if (std::find(move_possibles.begin(), move_possibles.end(), c2) != move_possibles.end())
                                    {
                                        if (!jouer_tour(Action{c->get_position(), c2->get_position()}))
                                        {
                                            return "Deplacement impossible";
                                        }
                                    }
                                    else
                                    {
                                        return "Movement illegal";
                                    }
                                }
                                else
                                {
                                    return "Ce n'est pas le tour de ce pion";
                                }
                            }
                            else
                            {
                                return "Case [" + std::to_string(p2.x()) + "; " + std::to_string(p2.y()) + "] non existante";
                            }
                        }
                        catch (const std::invalid_argument& e)
                        {
                            return "Coordonees invalides";
                        }
                    }
                    catch (const std::invalid_argument& e)
                    {
                        return "Coordonees invlalides";
                    }
                }
                else
                {
                    return "Case [" + std::to_string(p.x()) + "; " + std::to_string(p.y()) + "] non existante";
                }
            }
            catch (const std::invalid_argument& e)
            {
                return "Coordonees invalides";
            }
        }
        catch (const std::invalid_argument& e)
        {
            return "Coordonees invlalides";
        }
    }

    else
    {
        return "Commande inconnue";
    }

    return get_display_plateau();
}

/**
 * @brief Joue un tour avec une action donnée.
 * 
 * Gère le placement ou le déplacement d'insectes sur le plateau.
 * 
 * @param action Action à exécuter (placement ou déplacement).
 * @return bool True si l'action a été réalisée avec succès, False sinon.
 */
bool Partie::jouer_tour(Action action)
{
    if (partie_terminee)
        return false;

    if (!tour->est_abeille_placee() && nb_tours > 2 &&
        (!action.est_placement() || action.get_type() != Type::Type::ABEILLE))
        return false;

    if (action.est_placement())
    {
        if (ajouter_insecte(tour, plateau->get_case(action.get_arrivee()), action.get_type(), false))
        {
            actions.push_back(action);
        }
        else
            return false;
    }
    else
    {
        if (tour->est_abeille_placee() &&
            plateau->deplacer_insecte(plateau->get_case(action.get_depart()), plateau->get_case(action.get_arrivee())))
        {
            actions.push_back(action);
        }
        else
            return false;
    }

    if (!verifier_victoire())
    {
        if (tour == &joueur1)
            tour = &joueur2;

        else
        {
            tour = &joueur1;
            nb_tours++;
        }

        if(presence_ia && ia != nullptr && ia->get_partie()->get_tour_joueur() == ia->get_joueur_IA() && !(ia->get_en_fonctionnement()))
        {
            ia->faire_jouer_tour_IA();
        }
    }
    else
    {
        tour = &joueur1;
        partie_terminee = true;

        if (graphics)
            graphics->victoire();
    }

    return true;
}

/**
 * @brief Annule la dernière action du joueur.
 * 
 * Restaure l'état précédent du plateau en retirant ou en déplaçant des insectes.
 * 
 * @param joueur Joueur demandant l'annulation.
 * @return bool True si l'annulation a été effectuée, False sinon.
 */
bool Partie::annuler_action(Joueur* joueur, bool bypass) //bypass permet à l'ia d'annuler ses coups et ceux de l'adversaire pour le calcul du meilleur coup
{
    // Logique d'annulation des actions : voir le code original pour plus de détails.
    if (joueur->peut_undo()|| bypass)
    {
        if (nb_tours > 0)
        {
            if(!bypass && (joueur == &joueur2 || joueur == get_tour_joueur())) nb_tours--;

            joueur->utiliser_undo();
        }
        else
        {
            return false;
        }
    }
    else
        return false;

    Action action = actions.back();

    if (action.est_deplacement())
        plateau->deplacer_insecte(plateau->get_case(action.get_arrivee()), plateau->get_case(action.get_depart()), true);

    else
    {
        plateau->get_case(action.get_arrivee())->get_joueur()->remettre(plateau->get_case(action.get_arrivee())->get_pion()->get_type());
        plateau->retirer_insecte(plateau->get_case(action.get_arrivee()));
    }

    actions.pop_back();
    action = actions.back();


    // On annule encore un coup
    if (joueur == tour)
    {
        if (action.est_deplacement())
            plateau->deplacer_insecte(plateau->get_case(action.get_arrivee()), plateau->get_case(action.get_depart()), true);

        else
        {
            plateau->get_case(action.get_arrivee())->get_joueur()->remettre(plateau->get_case(action.get_arrivee())->get_pion()->get_type());
            plateau->retirer_insecte(plateau->get_case(action.get_arrivee()));
        }
    }
    else
    {
        tour = joueur;
    }

    actions.pop_back();

    return true;
}

/**
 * @brief Ajoute un insecte sur le plateau.
 * 
 * Crée un insecte du type spécifié et tente de le placer sur la case donnée.
 * 
 * @param joueur Joueur propriétaire de l'insecte.
 * @param c Case où l'insecte doit être placé.
 * @param type Type d'insecte à placer.
 * @param bypass Ignorer certaines vérifications (par défaut false).
 * @return bool True si l'insecte a été ajouté avec succès, False sinon.
 */
bool Partie::ajouter_insecte(Joueur* joueur, Case* c, Type::Type type, bool bypass)
{
    std::unique_ptr<Insecte> insecte = UsineInsecte::get_usine().fabriquer(type, joueur);

    if ((joueur->peut_utiliser(type) && plateau->placer_insecte(c, std::move(insecte), joueur, bypass)) || bypass)
    {
        if (type == Type::Type::ABEILLE)
        {
            joueur->set_abeille(c->get_pion());
        }
        return true;
    }
    return false;
}

/**
 * @brief Déplace un insecte d'une case à une autre.
 * 
 * Gère les vérifications nécessaires pour autoriser le déplacement.
 * 
 * @param joueur Joueur effectuant le déplacement.
 * @param depart Case de départ.
 * @param arrivee Case d'arrivée.
 * @param bypass Ignorer certaines vérifications (par défaut false).
 * @return bool True si le déplacement a été effectué, False sinon.
 */
bool Partie::deplacer_insecte(Joueur* joueur, Case* depart, Case* arrivee, bool bypass)
{
    return (tour == joueur && !Case::is_empty(depart) && depart->get_joueur() == joueur && plateau->deplacer_insecte(depart, arrivee, bypass));
}

/**
 * @brief Lit le prochain token (mot) dans une commande.
 * 
 * Sépare la commande en segments pour l'interprétation.
 * 
 * @param cmd Commande complète.
 * @param token Prochain token extrait de la commande.
 */
void Partie::lire_prochain_token(std::string &cmd, std::string &token)
{
    char delimiter = ' ';
    token = cmd.substr(0, cmd.find(delimiter));
    cmd = cmd.substr(cmd.find(delimiter) + 1);
}

/**
 * @brief Configure une partie de test.
 * 
 * Ajoute des insectes sur le plateau pour des tests.
 */
void Partie::setup_test()
{
    ajouter_insecte(&joueur1, plateau->get_case_base(), Type::Type::ABEILLE);
    ajouter_insecte(&joueur2, plateau->get_case_base()->get_case_from_direction(Case::Direction::BAS_DROIT), Type::Type::ABEILLE);
    ajouter_insecte(&joueur2, plateau->get_case_base()->get_case_from_direction(Case::Direction::HAUT_GAUCHE), Type::Type::SAUTERELLE);
}

/**
 * @brief Retourne une représentation textuelle du plateau.
 * 
 * Crée une vue sous forme de chaîne pour l'affichage CLI.
 * 
 * @return std::string Représentation textuelle du plateau.
 */
std::string Partie::get_display_plateau() const
{
    // Logique pour générer une représentation textuelle du plateau.
    std::string plateau_str = "";

    int x_max = plateau->get_cases()[0]->get_position().x();
    int x_min = plateau->get_cases()[0]->get_position().x();

    int y_max = plateau->get_cases()[0]->get_position().y();
    int y_min = plateau->get_cases()[0]->get_position().y();
    for (auto i_case : plateau->get_cases())
    {
        if (i_case->get_position().x() > x_max)
            x_max = i_case->get_position().x();

        else if (i_case->get_position().x() < x_min)
            x_min = i_case->get_position().x();

        if (i_case->get_position().y() > y_max)
            y_max = i_case->get_position().y();

        else if (i_case->get_position().y() < y_min)
            y_min = i_case->get_position().y();
    }

    int n_lignes = y_max - y_min + 1;
    int n_colonnes = x_max - x_min + 1;

    std::vector<std::string> plateau_str_vec;
    for (int i{0}; i < n_lignes; i++)
        plateau_str_vec.push_back(std::string(n_colonnes, ' '));

    for (auto i_case : plateau->get_cases())
    {
        if (Case::is_empty(i_case))
            plateau_str_vec[i_case->get_position().y() - y_min][i_case->get_position().x() - x_min]
                = '.';
        else
            plateau_str_vec[i_case->get_position().y() - y_min][i_case->get_position().x() - x_min]
                = Type::type_to_str(i_case->get_pion()->get_type())[0];
    }

    for (auto ligne : plateau_str_vec)
        plateau_str += ligne + "\n";

    return plateau_str;
}

/**
 * @brief Vérifie si un joueur a gagné la partie.
 * 
 * Parcourt le plateau pour déterminer si une abeille est encerclée.
 * 
 * @return bool True si un joueur a gagné, False sinon.
 */
bool Partie::verifier_victoire()
{
    return verifier_victoire_joueur(&joueur1) || verifier_victoire_joueur(&joueur2);
}

/**
 * @brief Vérifie si un joueur spécifique a gagné.
 * 
 * @param joueur Joueur à vérifier.
 * @return bool True si le joueur a gagné, False sinon.
 */
bool Partie::verifier_victoire_joueur(const Joueur* joueur) const
{
    // Logique pour vérifier si l'abeille du joueur est encerclée.
    if (!joueur->est_abeille_placee())
    {
        return false;
    }

    for (auto direction : Case::DIRECTIONS_ALL)
    {
        Case* case_voisine = joueur->get_abeille()->get_case()->get_case_from_direction(direction);
        if (Case::is_empty(case_voisine))
        {
            return false;
        }
    }

    return true;
}

/**
 * @brief Retourne le joueur gagnant.
 * 
 * @return Joueur* Pointeur vers le joueur gagnant ou nullptr si la partie n'est pas terminée.
 */
Joueur* Partie::get_gagnant() const
{
    return partie_terminee ? tour : nullptr;
}