/// <summary>
/// Changer la puissance d'un element
/// <obsolet>Cette méthode est obsolète. </obsolet>
/// </summary>
/// <param name="_element"></param>
/// <param name="_intToAdd"></param>
void ChangeEffetPuissance(Entite.Element _element, int _intToAdd)
{
/*
* Changer la puissance de toutes les cartes d'un certain élément.
* A AJOUTER DANS GERER ACTIONS.
*/
// La puissance de toutes les entités air sur le champ de bataille augmente de intEffet.
List <GameObject> carteElement = FindAllEntiteChampBatailleElement(_element);
Debug.Log("Changer effet puissance" + carteElement.Count.ToString());
for (int i = 0; i < carteElement.Count; ++i)
{
Debug.Log("Une carte affectée");
Entite _carte = carteElement[i].GetComponent <Entite>();
if (_carte.isFromLocalPlayer)
{
// on peut directement changer la STAT depuis la carte.
_carte.CmdAddStat(_intToAdd, 0);
}
else
{
FindLocalPlayer().GetComponent <Player>().CmdEnvoiMethodToServerCarteWithIntParameter(_carte.IDCardGame,
"CmdAddStat", _intToAdd, FindLocalPlayer().GetComponent <Player>().PlayerID);
}
}
}
/* ======================================================================================================
*
* METHODES ANNEXES
*
* ======================================================================================================
*/
/// <summary>
/// Transforme un string en un enum Entite.Element.
/// </summary>
/// <param name="ElementString">Le string de la base de données.</param>
/// <returns>Un Element de Entite.Element</returns>
public static Entite.Element stringToElement(string ElementString)
{
/*
* Transformer le string récupéré en un carte.Element.
*
*/
Entite.Element _element = Entite.Element.NONE;
switch (ElementString)
{
case "FEU":
_element = Entite.Element.FEU;
break;
case "AIR":
_element = Entite.Element.AIR;
break;
case "TERRE":
_element = Entite.Element.TERRE;
break;
case "EAU":
_element = Entite.Element.EAU;
break;
default:
// Si la carte est neutre, astrale ou maléfique.
_element = Entite.Element.NONE;
break;
}
return(_element);
}
/// <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'un élément donné
/// </summary>
/// <param name="element"></param>
/// <returns></returns>
public List <GameObject> CartesCorrespondantesElement(Entite.Element element)
{
Dictionary <string, List <GameObject> > uniqueCards = getUniqueCards();
List <GameObject> entites = CartesCorrespondantesType(CarteType.Type.ENTITE);
List <GameObject> elementList = new List <GameObject>();
foreach (GameObject g in entites)
{
if (g.GetComponent <Entite>().EntiteElement == element)
{
elementList.Add(g);
}
}
return(elementList);
}
/// <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;
}
