public Entite.Ascendance stringToAscendance(string AscendanceString)
{
/*
* Transformer le string récupéré en un carte.Ascendance.
*
*/
Entite.Ascendance _ascendance = Entite.Ascendance.NONE;
switch (AscendanceString)
{
case "ASTRALE":
_ascendance = Entite.Ascendance.ASTRALE;
break;
case "MALEFIQUE":
_ascendance = Entite.Ascendance.MALEFIQUE;
break;
default:
// Si la carte est élémentaire (dans nature, il y aura écrit, FEU, TERRE, AIR ou EAU);
_ascendance = Entite.Ascendance.NONE;
break;
}
return(_ascendance);
}
/// <summary>
/// Filtrer les entités par type d'élémentaires.
/// </summary>
/// <param name="filtre"></param>
public void FiltreElementaire(string filtre)
{
// Dans le cas du filtre d'une entité élementaire
if (filtre == "TERRE" || filtre == "EAU" || filtre == "FEU" || filtre == "AIR")
{
Entite.Element elementFiltre = Entite.Element.NONE;
switch (filtre)
{
case "TERRE":
elementFiltre = Entite.Element.TERRE;
break;
case "FEU":
elementFiltre = Entite.Element.FEU;
break;
case "EAU":
elementFiltre = Entite.Element.EAU;
break;
case "AIR":
elementFiltre = Entite.Element.AIR;
break;
default:
Debug.LogError("Ce cas ne peut pas arriver");
break;
}
ResetFiltres();
filtreElementaire = elementFiltre;
PutCardsInScrollView("allCards", CartesCorrespondantesElement(elementFiltre), true);
}
else if (filtre == "ASTRAL" || filtre == "MALEFIQUE")
{
Entite.Ascendance ascendanceFiltre = Entite.Ascendance.NONE;
if (filtre == "ASTRAL")
{
ascendanceFiltre = Entite.Ascendance.ASTRALE;
}
else
{
ascendanceFiltre = Entite.Ascendance.MALEFIQUE;
}
ResetFiltres();
filtreAscendance = ascendanceFiltre;
PutCardsInScrollView("allCards", CartesCorrespondantesAscendance(ascendanceFiltre), true);
}
else
{
throw new Exception("Ce filtre n'existe pas");
}
ListeFiltreElementaires.SetActive(false);
tri = Tri.NONE;
}
/// <summary>
/// Récupérer toutes les cartes d'une ascendance donnée.
/// </summary>
/// <param name="ascendance"></param>
/// <returns></returns>
public List <GameObject> CartesCorrespondantesAscendance(Entite.Ascendance ascendance)
{
Dictionary <string, List <GameObject> > uniqueCards = getUniqueCards();
List <GameObject> entites = CartesCorrespondantesType(CarteType.Type.ENTITE);
List <GameObject> ascendanceList = new List <GameObject>();
foreach (GameObject g in entites)
{
if (g.GetComponent <Entite>().EntiteAscendance == ascendance)
{
ascendanceList.Add(g);
}
}
return(ascendanceList);
}
/// <summary>
/// Cette méthode est TEMPORAIRE.
/// Elle permet juste d'ajouter une touche de visuel.
/// </summary>
/// <param name="element"></param>
/// <param name="ascendance"></param>
/// <returns></returns>
public Color GetCouleurCarte()
{
// Si c'est une entité.
if (GetComponent <Carte>().IsEntite())
{
Entite.Element element = GetComponent <Entite>().EntiteElement;
Entite.Ascendance ascendance = GetComponent <Entite>().EntiteAscendance;
Entite.Nature nature = GetComponent <Entite>().EntiteNature;
switch (element)
{
case Entite.Element.AIR:
// On retourne une teinte verte
return(new Color(0, 1, 0));
case Entite.Element.EAU:
return(new Color(0, 0, 1));
case Entite.Element.FEU:
return(new Color(1, 0, 0));
case Entite.Element.TERRE:
return(new Color(1, 190f / 255f, 73f / 255f));
case Entite.Element.NONE:
// On ne met pas de couleur ici
break;
}
switch (ascendance)
{
case Entite.Ascendance.ASTRALE:
return(Color.white);
case Entite.Ascendance.MALEFIQUE:
// Couleur grise.
return(new Color(0.5f, 0, 1f));
case Entite.Ascendance.NONE:
// On ne met aps de couleur ici.
break;
}
if (nature == Entite.Nature.NEUTRE)
{
return(new Color(0.4f, 0.4f, 0.4f));
}
}
// Si c'est un sort.
else if (GetComponent <Carte>().IsSort())
{
return(Color.white);
}
// Si c'est une assistance.
else if (GetComponent <Carte>().IsAssistance())
{
return(Color.white);
}
Debug.LogError("On ne devrait pas arriver ici normalement. ");
return(Color.white);
}
public void ResetFiltres()
{
filtreAscendance = Entite.Ascendance.NONE;
filtreElementaire = Entite.Element.NONE;
filtreType = CarteType.Type.AUCUN;
}
