case.cpp

#include "case.h"
#include "insecte.h"
#include "graphicscase.h"

#include <iostream>

/**
 * @brief Retourne la direction opposée à une direction donnée.
 * 
 * @param direction La direction pour laquelle l'opposée est demandée.
 * @return Case::Direction La direction opposée.
 */
Case::Direction Case::DIRECTION_OPPOSE(Direction direction)
{
    switch (direction)
    {
    case Direction::HAUT_DROIT:
        return Direction::BAS_GAUCHE;
    case Direction::DROITE:
        return Direction::GAUCHE;
    case Direction::BAS_DROIT:
        return Direction::HAUT_GAUCHE;
    case Direction::HAUT_GAUCHE:
        return Direction::BAS_DROIT;
    case Direction::GAUCHE:
        return Direction::DROITE;
    case Direction::BAS_GAUCHE:
        return Direction::HAUT_DROIT;
    default:
        return Direction::NONE;
    }
}

/**
 * @brief Convertit une direction en incrément de position.
 * 
 * @param direction La direction à convertir.
 * @return QPoint L'incrément correspondant à la direction donnée.
 */
QPoint Case::direction_to_position_increment(Direction direction)
{
    switch (direction)
    {
    case Direction::HAUT_DROIT:
        return QPoint(1, 1);
    case Direction::DROITE:
        return QPoint(2, 0);
    case Direction::BAS_DROIT:
        return QPoint(1, -1);
    case Direction::HAUT_GAUCHE:
        return QPoint(-1, 1);
    case Direction::GAUCHE:
        return QPoint(-2, 0);
    case Direction::BAS_GAUCHE:
        return QPoint(-1, -1);
    default:
        return QPoint(0, 0);
    }
}

/**
 * @brief Constructeur de la classe Case.
 * 
 * @param position La position de la case sur le plateau.
 * @param plateau Pointeur vers le plateau auquel la case appartient.
 */
Case::Case(QPoint position, Plateau *plateau) : position(position), plateau(plateau)
{
    pion = nullptr;
}

/**
 * @brief Crée une nouvelle case adjacente dans la direction donnée.
 * 
 * @param direction La direction dans laquelle créer la nouvelle case.
 * @param plateau Pointeur constant vers le plateau.
 * @return Case* Pointeur vers la case créée, ou nullptr en cas d'erreur.
 */
Case* Case::creer_case(Direction direction, Plateau* const plateau)
{
    Case** case_a_creer = case_ptr_from_direction(direction);

    if (!case_a_creer)
    {
        std::cout << "Erreur dans la direction de la case à créer" << std::endl;
        return nullptr;
    }
    if (*case_a_creer)
    {
        std::cout << "La case à créer existe déjà" << std::endl;
        return nullptr;
    }
    *case_a_creer = new Case(position + direction_to_position_increment(direction), plateau);

    if (!*case_a_creer)
    {
        std::cout << "Impossible de créer une nouvelle case." << std::endl;
        return nullptr;
    }
    return *case_a_creer;
}

/**
 * @brief Récupère la case adjacente dans une direction donnée.
 * 
 * @param direction La direction dans laquelle chercher la case adjacente.
 * @return Case* Pointeur vers la case adjacente, ou nullptr si elle n'existe pas.
 */
Case* Case::get_case_from_direction(Direction direction) const
{
    Case* case_cherchee = nullptr;

    switch (direction)
    {
    case Direction::HAUT_DROIT:
        case_cherchee = haut_droit;
        break;
    case Direction::DROITE:
        case_cherchee = droite;
        break;
    case Direction::BAS_DROIT:
        case_cherchee = bas_droit;
        break;
    case Direction::HAUT_GAUCHE:
        case_cherchee = haut_gauche;
        break;
    case Direction::GAUCHE:
        case_cherchee = gauche;
        break;
    case Direction::BAS_GAUCHE:
        case_cherchee = bas_gauche;
        break;
    default:
        case_cherchee = nullptr;
    }

    return case_cherchee;
}

/**
 * @brief Récupère le joueur associé à la case.
 * 
 * @return Joueur* Pointeur vers le joueur possédant l'insecte sur la case, ou nullptr si la case est vide.
 */
class Joueur* Case::get_joueur() const
{
    return get_pion() ? pion->get_joueur() : nullptr;
}

/**
 * @brief Récupère un pointeur vers une case adjacente dans une direction donnée.
 * 
 * @param direction La direction dans laquelle chercher.
 * @return Case** Pointeur vers le pointeur de la case adjacente, ou nullptr si elle n'existe pas.
 */
Case** Case::case_ptr_from_direction(Direction direction)
{
    Case** case_cherchee = nullptr;

    switch (direction)
    {
    case Direction::HAUT_DROIT:
        case_cherchee = &haut_droit;
        break;
    case Direction::DROITE:
        case_cherchee = &droite;
        break;
    case Direction::BAS_DROIT:
        case_cherchee = &bas_droit;
        break;
    case Direction::HAUT_GAUCHE:
        case_cherchee = &haut_gauche;
        break;
    case Direction::GAUCHE:
        case_cherchee = &gauche;
        break;
    case Direction::BAS_GAUCHE:
        case_cherchee = &bas_gauche;
        break;
    default:
        case_cherchee = nullptr;
    }

    return case_cherchee;
}

/**
 * @brief Destructeur par défaut de la classe Case.
 */
Case::~Case() = default;