public List <Unite> GetUnitInTerritoire(Route cible)
{
if (this.routes.Contains(cible))
{
List <Unite> result = new List <Unite>();
foreach (Unite unit in unites)
{
if (unit.GetType().Name == "Croiseur" || unit.GetType().Name == "Submarin")
{
Maritime maritime = unit as Maritime;
if (maritime.route.Equals(cible))
{
result.Add(maritime);
}
}
}
return(result);
}
else
{
throw new InvalidRouteException("Cette route n'appartient pas au joueur actuel.");
}
}
/// <summary>
/// Affiche la fenêtre de sélection de cibles pour les attaques maritimes.
/// </summary>
/// <param name="toAttack">Route La route maritime à attaquer.</param>
public void TargetsSelection(Route toAttack)
{
Transform unitesTargetableList = targetSelectionPanel.transform.FindChild("Unités");
targetSelectionPanel.transform.FindChild("Cible").GetComponent <Text>().text = "" + GameObject.Find("Territoires colorés").GetComponent <ColoredTerritories>().GetRouteIndex(toAttack);
Dictionary <int, Maritime> maritimes = new Dictionary <int, Maritime>();
// Récupération des unités défensives.
foreach (Unite unit in toAttack.joueur.Unites)
{
if (unit.GetType().Name == "Croiseur" || unit.GetType().Name == "Submarin")
{
Maritime maritime = unit as Maritime;
if (maritime.route.Equals(toAttack))
{
maritimes.Add(toAttack.joueur.Unites.IndexOf(maritime), maritime);
}
}
}
int i = 0;
int offset = maritimes.Count % 2 == 0 ? -55 : 0; // La coordonnées x du premier élément de la liste d'unité à afficher
Dictionary <int, Maritime> .Enumerator maritimesEnum = maritimes.GetEnumerator();
while (maritimesEnum.MoveNext())
{
GameObject prefab;
// Le prefab de l'entrée pour le panel de sélection de cible
if (maritimesEnum.Current.Value.GetType().Name == "Croiseur")
{
prefab = targetSelectionPrefabs[0];
}
else
{
prefab = targetSelectionPrefabs[1];
}
Instantiate(prefab, unitesTargetableList);
Transform newEntry = unitesTargetableList.GetChild(unitesTargetableList.childCount - 1);
// La coordonnées x est calculée en fonction de l'index de la boucle et de si le nombre d'unités est pair ou impair :
// 1. Pour centrer les unités, on les place du centre vers les extérieurs en alternant gauche et droite,
// d'où le Math.Pow(-1, i) : on décale sur la droite (Math.Pow > 0) ou la gauche (Math.Pow < 0).
// 2. Le décalage se fait par "cran" de 125. Pour connaitre le nombre de cran, on additionne le résultat
// de la division du rang de l'unité par 2 au reste de cette même division (i / 2 + i % 2).
// Ainsi, la première unité est le centre de la rangée (i/2 + i%2 = 0) et les unités suivantes apparaitront pour l'encadrer
// 3. Enfin, ceci ne fonctionne que pour un nombre impair d'unités. Pour permettre le centrage d'un nombre pair
// on ajoute l'offset défini plus haut.
newEntry.localPosition = new Vector3((float)Math.Pow(-1, i) * 125 * (i / 2 + i % 2) + offset, 0, 0);
newEntry.rotation = new Quaternion();
newEntry.localScale = new Vector3(1.0f, 1.0f, 1.0f);
// L'index permettra de supprimer l'unité visée lors de la résolution de l'attaque.
newEntry.GetChild(newEntry.childCount - 1).gameObject.GetComponent <Text>().text = "" + maritimesEnum.Current.Key;
++i;
}
OpenDialog(targetSelectionPanel);
}
/// <summary>
/// Active le changement de phase/tour
/// </summary>
public void PasserButton()
{
if (!GetComponent <GUIController>().dialogOpened) // S'il n'y a pas de fenêtre de dialogue d'ouverte
{
if (phaseActive == phases.Deploiement)
{
List <Unite> .Enumerator unitsEnum = joueurs[joueurActif].Unites.GetEnumerator();
bool canPass = true;
while (canPass && unitsEnum.MoveNext())
{
if (unitsEnum.Current is Terrestre)
{
Terrestre unit = unitsEnum.Current as Terrestre;
if (unit.territoire == null)
{
canPass = false;
}
}
else if (unitsEnum.Current is Aerienne)
{
Aerienne unit = unitsEnum.Current as Aerienne;
if (unit.territoire == null)
{
canPass = false;
}
}
else
{
Maritime unit = unitsEnum.Current as Maritime;
if (unit.route == null)
{
canPass = false;
}
}
}
if (canPass)
{
phaseActive = phases.Attaque;
if (!joueurs[joueurActif].Humain)
{
IAEasy joueurIA = joueurs[joueurActif] as IAEasy;
joueurIA.IAPlay();
}
}
else
{
InvalidAction("Vous ne pouvez passer votre tour sans déployer toutes les unités nouvellement achetées.");
}
}
else if (phaseActive == phases.Attaque)
{
phaseActive = phases.Mouvement;
if (!joueurs[joueurActif].Humain)
{
IAEasy joueurIA = joueurs[joueurActif] as IAEasy;
joueurIA.IAPlay();
}
else
{
button.transform.GetChild(0).GetComponent <Text>().text = "Fin du tour";
}
}
else if (phaseActive == phases.Mouvement)
{
ChangeActivePlayer();
}
}
}
/// <summary>
/// Détruit les unités maritimes en fonction du résultat des dés.
/// </summary>
/// <param name="diceAtt">int[] Les dés de l'attaquant.</param>
/// <param name="diceDef">int[] Les dés du défenseur.</param>
/// <param name="targetsIds">int[] les index des cibles dans la liste des unités du défenseur.</param>
private void DestroyUnits(int[] diceAtt, int[] diceDef, int[] targetsIds)
{
int toDestroyAtt = 0, toDestroyDef = 0;
// Tri dans l'ordre croissant
Array.Sort(diceAtt);
Array.Sort(diceDef);
// Comparaison des plus gros chiffres tirés par chaque joueur
if (diceAtt[diceAtt.Length - 1] > diceDef[diceDef.Length - 1])
{
toDestroyDef++;
}
else
{
toDestroyAtt++;
}
// Comparaison des seconds plus gros chiffres tirés par chaque joueur
if (diceAtt.Length > 1 && diceDef.Length > 1)
{
if (diceAtt[diceAtt.Length - 2] > diceDef[diceDef.Length - 2])
{
toDestroyDef++;
}
else
{
toDestroyAtt++;
}
}
List <Submarin> toDestroy = new List <Submarin>();
int i = 0;
while (i < toDestroyAtt)
{
unitesDetruitesAtt[(int)Utils.unitCode.Submarin]++;
foreach (Submarin sub in subAtt)
{
if (!sub.Equals(subAtt[i]))
{
sub.RemoveFromSelection(subAtt[i]);
}
}
toDestroy.Add(subAtt[i]);
i++;
}
foreach (Submarin sub in toDestroy)
{
sub.Joueur.Unites.Remove(sub);
sub.route.unites.Remove(sub);
subAtt.Remove(sub);
Destroy(sub.gameObject);
}
i = 0;
List <Maritime> maritimes = new List <Maritime>(toDestroyDef);
while (i < toDestroyDef)
{
Unite unit = routeCible.joueur.Unites[targetsIds[i]];
Maritime maritime = unit as Maritime;
if (unit.GetType().Name == "Croiseur")
{
unitesDetruitesDef[(int)Utils.unitCode.Croiseur]++;
}
else
{
unitesDetruitesDef[(int)Utils.unitCode.Submarin]++;
}
maritimes.Add(maritime);
i++;
}
foreach (Maritime current in maritimes)
{
current.route.unites.Remove(current);
current.Joueur.Unites.Remove(current);
unitDef.Remove(current);
Destroy(current.gameObject);
}
}
/// <summary>
/// Lance l'attaque sur le territoire cible.
/// </summary>
/// <param name="unitAttacking">List(Submarin) Les sous-marins donnant l'assaut.</param>
/// <param name="cible">Territoire Le territoire cible.</param>
/// <param name="targetsIds">int[] Les index des unités ciblées dans la liste d'unités du défenseur.</param>
public IEnumerator LaunchAttack(List <Submarin> unitAttacking, Route cible, int[] targetsIds)
{
routeCible = cible;
subAtt = unitAttacking;
joueurAtt = subAtt[0].Joueur;
joueurDef = cible.joueur;
// Récupération des unités présentes sur la cible
foreach (Unite unit in cible.joueur.Unites)
{
if (unit.GetType().BaseType.Name == "Maritime")
{
Maritime maritime = unit as Maritime;
if (maritime.route.Equals(cible))
{
unitDef.Add(maritime);
}
}
}
int[] diceAtt = new int[Math.Min(3, subAtt.Count)], diceDef = new int[Math.Min(2, unitDef.Count)];
System.Random rand = new System.Random();
// Jets de dés
for (int i = 0; i < 3; i++)
{
if (i < Math.Min(3, subAtt.Count))
{
diceAtt[i] = rand.Next(1, 7); // Tire un chiffre entre 1 et 7 non inclus
}
if (i < Math.Min(2, unitDef.Count))
{
diceDef[i] = rand.Next(1, 7);
}
}
DestroyUnits(diceAtt, diceDef, targetsIds);
foreach (Submarin unit in subAtt)
{
unit.Disable();
unitAtt.Add(unit);
}
// Si toutes les unités de la défense sont détruites, la route est à nouveau libre.
if (unitDef.Count == 0 && unitAtt.Count > 0)
{
joueurDef.Routes.Remove(cible);
joueurAtt.Routes.Add(cible);
foreach (Submarin unit in subAtt)
{
unit.route = cible;
}
}
else
{
unitAtt[0].ResetPosition();
}
// Affichage du résultat de l'assaut.
yield return(StartCoroutine(GameObject.Find("GUIManager").GetComponent <GUIController>().ShowAssaultResult(diceAtt, diceDef, unitesDetruitesAtt, unitesDetruitesDef, unitAtt, unitDef)));
// Réinitialisation des variables pour éviter toute erreur.
Reset();
}
