/// <summary>Déplacement des unités de l'IA lorsqu'il a la main sur les territoires non occupés par un ennemi.</summary>
public void IAUniteDeploiement()
{
Dictionary <int, Territoire> .Enumerator territoiresEnum = coloredTerritories.Territoires.GetEnumerator();
bool deploye = false;
// Recherche d'un territoire libre pour le réclamer et y placer une infanterie
while (!deploye && territoiresEnum.MoveNext())
{
if (territoiresEnum.Current.Value.joueur == null)
{
deploye = true;
Territoire newTerritoire = territoiresEnum.Current.Value;
newTerritoire.joueur = this;
AddTerritoire(newTerritoire);
Infanterie newUnit = boutique.CreateUnit(
(int)Utils.unitCode.Infanterie,
GameObject.Find("Unites").transform,
newTerritoire.position, this
).gameObject.GetComponent <Infanterie>();
newUnit.territoire = newTerritoire;
newTerritoire.unites.Add(newUnit);
}
}
}
public Manche(int nb, IDictionary <int, string> difficulte)
{
Infanterie inf = new Infanterie("soldat", null);
Char char1 = new Char("Char", null);
for (int i = 0; i < computeNbEnemies(nb); i++)
{
this.ennemies.Add(computeEnemies(new Random().Next(2)));
}
}
private IEnumerator Start()
{
int nbrJoueurs = 1, nbrIas = 1, i = 0;
joueurs = new Dictionary <int, Joueur>(nbrJoueurs);
Transform joueursGameObject = GameObject.Find("Joueurs").transform;
// Création des joueurs.
for (i = 0; i < nbrJoueurs; i++)
{
Instantiate(playerPrefabs[0], joueursGameObject);
Joueur joueur = joueursGameObject.GetChild(joueursGameObject.childCount - 1).GetComponent <Joueur>();
InitialisePlayer(joueur, "Joueur" + (i + 1), true, (Utils.couleurs)i);
joueurs.Add(i, joueur);
}
for (i = 0; i < nbrIas; i++)
{
Instantiate(playerPrefabs[1], joueursGameObject);
IAEasy iae = joueursGameObject.GetChild(joueursGameObject.childCount - 1).GetComponent <IAEasy>();
InitialisePlayer(iae, "IA" + (i + 1), false, (Utils.couleurs)nbrJoueurs + i);
joueurs.Add(nbrJoueurs + i, iae);
}
territoires = coloredTerritories.Territoires;
routes = coloredTerritories.Routes;
List <Territoire> territoireAAttribuer = new List <Territoire>(territoires.Count);
System.Random rand = new System.Random();
for (i = 0; i < territoires.Count; i++)
{
territoireAAttribuer.Add(territoires[i]);
}
i = 0;
BoutiqueManager boutique = GameObject.Find("Boutique button").GetComponent <BoutiqueManager>();
// Ajout de territoires aux joueurs de façon arbitraire.
while (territoireAAttribuer.Count > 0)
{
// Sélection aléatoire du territoire à attribuer.
int index = rand.Next(0, territoireAAttribuer.Count);
while (joueurs[i % joueurs.Count].Ready == false)
{
yield return(null);
}
joueurs[i % joueurs.Count].Territoires.Add(territoireAAttribuer[index].Num, territoireAAttribuer[index]);
// Ajout d'une infanterie pour marquer quel territoire appartient à qui.
Infanterie newUnit = boutique.CreateUnit(
(int)Utils.unitCode.Infanterie,
GameObject.Find("Unites").transform,
territoireAAttribuer[index].position,
joueurs[i % joueurs.Count]
).GetComponent <Infanterie>();
newUnit.territoire = territoireAAttribuer[index];
territoireAAttribuer[index].unites.Add(newUnit);
territoireAAttribuer[index].joueur = joueurs[i % joueurs.Count];
territoireAAttribuer.RemoveAt(index);
i++;
// Au cas où ce serait un peu long.
yield return(null);
}
// Application des bonnes couleurs pour chaque unité.
for (i = 0; i < joueurs.Count; i++)
{
foreach (Unite unit in joueurs[i].Unites)
{
unit.lightMaterial = joueurs[i].Material;
unit.darkMaterial = joueurs[i].DarkMaterial;
unit.ApplyMaterial(unit.darkMaterial);
}
}
// Initialisation des fonds du premier joueur.
joueurs[0].AjouterCredits(joueurs[0].EstimatedEarnings());
}
/// <summary>
/// Détruit les unités terrestres et aériennes 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="ranged">bool Variable d'état définissant si l'attaque est à distance ou non.</param>
private void DestroyUnits(int[] diceAtt, int[] diceDef, bool ranged)
{
int toDestroyAtt = 0, toDestroyDef = 0;
int totalAtt = 0, totalDef = 0, i = 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++;
}
}
// Somme des dés de l'attaque
for (i = 0; i < diceAtt.Length; i++)
{
totalAtt += diceAtt[i];
}
// Somme des dés de la défense
for (i = 0; i < diceDef.Length; i++)
{
totalDef += diceDef[i];
}
// Si la somme de l'attaquant est supérieure au défenseur, on détruit un tank du défenseur s'il y en a
if (totalAtt > totalDef)
{
unitDef = DestroyTank(unitDef, true);
}
else// Autrement, c'est un tank de l'attaquant
{
unitAtt = DestroyTank(unitAtt, false);
}
List <Dca> dcasInRange = territoireCible.GetDcaInRange();
if (toDestroyAtt > 0 && unitAtt.Count > 0 && (!ranged || (unitAtt[0].GetType().Name == "Bombardier" && dcasInRange.Count > 0)))
{
List <Unite> .Enumerator unitesEnum = unitAtt.GetEnumerator();
List <Unite> toDestroy = new List <Unite>();
// On ne peut détruire plus de bombardier qu'il n'y a de DCA.
// Si unitAtt[0] == null alors il s'agissait d'un tank donc la liste ne contient pas de bombardier
if (unitAtt[0] != null && unitAtt[0].GetType().Name == "Bombardier")
{
toDestroyAtt = Math.Min(toDestroyAtt, dcasInRange.Count);
}
while (toDestroyAtt > 0 && unitesEnum.MoveNext())
{
if (unitesEnum.Current.GetType().Name != "Tank")
{
if (unitesEnum.Current.GetType().Name == "Bombardier")
{
unitesDetruitesAtt[(int)Utils.unitCode.Bombardier]++;
}
if (unitesEnum.Current.GetType().Name == "Infanterie")
{
unitesDetruitesAtt[(int)Utils.unitCode.Infanterie]++;
}
foreach (Unite unit in unitAtt)
{
if (!unit.Equals(unitesEnum.Current))
{
unit.RemoveFromSelection(unitesEnum.Current);
}
}
toDestroy.Add(unitesEnum.Current);
--toDestroyAtt;
}
}
foreach (Unite unit in toDestroy)
{
if (unit.GetType().Name == "Bombardier")
{
Bombardier bomber = unit as Bombardier;
bomber.territoire.unites.Remove(bomber);
}
if (unit.GetType().Name == "Infanterie")
{
Infanterie infanterie = unit as Infanterie;
infanterie.territoire.unites.Remove(infanterie);
}
unit.Joueur.Unites.Remove(unit);
unitAtt.Remove(unit);
Destroy(unit.gameObject);
}
}
// Si c'est une attaque à distance, on laisse une unité en vie.
int minUnitToLeaveAlive = ranged ? 1 : 0;
if (toDestroyDef > minUnitToLeaveAlive)
{
List <Bombardier> bombardiers = new List <Bombardier>();
List <Dca> dcas = new List <Dca>();
List <Artillerie> artilleries = new List <Artillerie>();
List <Infanterie> infanteries = new List <Infanterie>();
foreach (Unite unit in unitDef)
{
if (unit.GetType().Name == "Bombardier")
{
bombardiers.Add(unit as Bombardier);
}
if (unit.GetType().Name == "Dca")
{
dcas.Add(unit as Dca);
}
if (unit.GetType().Name == "Artillerie")
{
artilleries.Add(unit as Artillerie);
}
if (unit.GetType().Name == "Infanterie")
{
infanteries.Add(unit as Infanterie);
}
}
List <Bombardier> .Enumerator bombardiersEnum = bombardiers.GetEnumerator();
List <Dca> .Enumerator dcasEnum = dcas.GetEnumerator();
List <Artillerie> .Enumerator artilleriesEnum = artilleries.GetEnumerator();
List <Infanterie> .Enumerator infanteriesEnum = infanteries.GetEnumerator();
List <Unite> toDestroy = new List <Unite>();
while (toDestroyDef > minUnitToLeaveAlive && bombardiersEnum.MoveNext())
{
unitesDetruitesDef[(int)Utils.unitCode.Bombardier]++;
bombardiersEnum.Current.territoire.unites.Remove(bombardiersEnum.Current);
toDestroy.Add(bombardiersEnum.Current);
--toDestroyDef;
}
while (toDestroyDef > minUnitToLeaveAlive && dcasEnum.MoveNext())
{
unitesDetruitesDef[(int)Utils.unitCode.DCA]++;
dcasEnum.Current.territoire.unites.Remove(dcasEnum.Current);
toDestroy.Add(dcasEnum.Current);
--toDestroyDef;
}
while (toDestroyDef > minUnitToLeaveAlive && artilleriesEnum.MoveNext())
{
unitesDetruitesDef[(int)Utils.unitCode.Artillerie]++;
artilleriesEnum.Current.territoire.unites.Remove(artilleriesEnum.Current);
toDestroy.Add(artilleriesEnum.Current);
--toDestroyDef;
}
while (toDestroyDef > minUnitToLeaveAlive && infanteriesEnum.MoveNext())
{
unitesDetruitesDef[(int)Utils.unitCode.Infanterie]++;
infanteriesEnum.Current.territoire.unites.Remove(infanteriesEnum.Current);
toDestroy.Add(infanteriesEnum.Current);
--toDestroyDef;
}
foreach (Unite unit in toDestroy)
{
unit.Joueur.Unites.Remove(unit);
unitDef.Remove(unit);
Destroy(unit.gameObject);
}
}
}
