scarabe.cpp

#include "scarabe.h"
#include "insecte.h"
#include "case.h"
#include "usineinsecte.h"

/**
 * @brief Constructeur de la classe Scarabe.
 * 
 * Initialise un scarabée appartenant au joueur spécifié.
 * 
 * @param joueur Pointeur vers le joueur propriétaire du scarabée.
 */

Scarabe::Scarabe(class Joueur* joueur) : Insecte(joueur)
{

}
/**
 * @brief Calcule les déplacements possibles pour le scarabée.
 * 
 * Le scarabée peut se déplacer sur n'importe quelle case adjacente, même si cette case est occupée par un autre insecte.
 * Il peut également se déplacer sur des cases vides s'il existe un insecte adjacent pour assurer un glissement valide.
 * 
 * @param move_possibles Référence vers un vecteur où les déplacements possibles seront ajoutés.
 */
void Scarabe::get_moves_possibles(std::vector<Case *> &move_possibles) const
{
    if (!move_casse_ruche(get_case()))
    {
        for (auto i_direction : Case::DIRECTIONS_ALL)
        {
            Case* c = get_case()->get_case_from_direction(i_direction);
            // Si le scarabée est déjà sur un autre insecte ou que la case adjacente n'est pas vide
            if (get_en_dessous() || !Case::is_empty(c))
                move_possibles.push_back(c);

            else
            {
                // Vérifie s'il y a un insecte environnant pour permettre un glissement
                bool a_insecte_environnant = false;
                for (auto j_direction : Case::DIRECTIONS_ALL)
                {
                    if (i_direction != Case::DIRECTION_OPPOSE(j_direction))
                    {
                        if (!Case::is_empty(c->get_case_from_direction(j_direction)))
                        {
                            a_insecte_environnant = true;
                            break;
                        }
                    }
                }

                if (a_insecte_environnant)
                    move_possibles.push_back(c);
            }
        }
    }


/**
 * @brief Enregistre la classe Scarabe dans l'usine d'insectes.
 * 
 * Permet de créer dynamiquement des instances de Scarabe via l'UsineInsecte.
 */

    
}

bool Scarabe::enregistre = UsineInsecte::get_usine().enregistrer_type(Type::Type::SCARABE, [](Joueur* joueur) {
    return std::make_unique<Scarabe>(joueur);
});