// Update is called once per frame
void LateUpdate()
{
if (dragNDrop)
{
foreach (TuileManager tuile in tuilesAmenageables)
{
tuile.ColorerTuile(tuile.couleurTuileSurChemin);
}
rectTConso.position = Input.mousePosition;
if (Input.GetMouseButtonUp(0) && controlesActifs)
{
ControleSouris.Actuel.controleEstActif = true;
LayerMask maskTuile = LayerMask.GetMask("Tuile");
Collider2D checkTuile = Physics2D.OverlapBox(Camera.main.ScreenToWorldPoint(Input.mousePosition), new Vector2(0.01f, 0.01f), 0, maskTuile);
if (checkTuile)
{
TuileManager tuile = checkTuile.GetComponent <TuileManager>();
FenetreValidation.OuvrirFenetreValidation("Voulez-vous consommer cet aménagement et amnéger cette tuile ?",
"Oui", "Non", () => ConsommerAmenagement(tuile), consommable.icone, consommable.texteRetour);
return;
}
ReinitConso();
}
if (dragNDrop)
{
controlesActifs = true;
}
}
}
private void Peindre()
{
if (modePeinture)
{
foreach (GameObject go in Selection.gameObjects)
{
if (go.GetComponent <TuileManager>())
{
TuileManager tuile = go.GetComponent <TuileManager>();
//Debug.Log(terrainSelectionne.nom);
if (tuile.gameObject.name != "TuileHexa")
{
tuile.SetTerrain(terrainSelectionne);
}
}
else if (go.GetComponentInParent <TuileManager>())
{
TuileManager tuile = go.GetComponentInParent <TuileManager>();
//Debug.Log(terrainSelectionne.nom);
if (tuile.gameObject.name != "TuileHexa")
{
tuile.SetTerrain(terrainSelectionne);
}
}
}
Selection.objects = new Object[0];
}
}
public IEnumerator SeDeplacer()
{
if (chemin.Count <= 1)
{
ptsDeplacement = 0;
}
if (ptsDeplacement > 0)
{
prochaineTuile = chemin.Pop();
if (CheckerFleuve(prochaineTuile.transform.position))
{
traverseFleuve = true;
}
//Tant qu'on est pas arrivé à la prochaine tuile, on avance vers elle
//simule un Update() avec le WaitForEndOfFrame()
while (!EstArrivePrichaineTuile())
{
SeDeplacerALaProchaineTuile();
yield return(new WaitForEndOfFrame());
}
//On diminue les points de deplacements disponibles fonction de si on a traversé un fleuve ou pas
if (traverseFleuve)
{
ptsDeplacement--;
}
ptsDeplacement -= tuileActuelle.connectionsDistance[tuileActuelle.RecupIndexConnection(prochaineTuile)];
TrouverTuileActuelle();
}
aFaitUneAction = true;
}
public void SpawnTroupeau()
{
GameObject troupeauASpawn = ListeAnimaux.Defaut.domesticables[Random.Range(0, ListeAnimaux.Defaut.domesticables.Count - 1)];
TuileManager[] tuilesFront = DamierGen.Actuel.RecupTuilesFrontalieres();
List <TuileManager> tuilesPlaine = new List <TuileManager>();
for (int i = 0; i < tuilesFront.Length; i++)
{
if (tuilesFront[i].terrainTuile is TerrainPlaine && !tuilesFront[i].estOccupee)
{
tuilesPlaine.Add(tuilesFront[i]);
}
}
if (tuilesPlaine.Count > 0)
{
TuileManager tuileSpawn = tuilesPlaine[Random.Range(0, tuilesPlaine.Count - 1)];
Vector3 positionSpawn = tuileSpawn.transform.position;
positionSpawn.z = -3.5f;
GameObject nvTroupeau = Instantiate(troupeauASpawn, positionSpawn, new Quaternion());
nvTroupeau.name = troupeauASpawn.name;
CameraControle.Actuel.CentrerCamera(nvTroupeau.transform.position);
}
}
public void TuileReinit()
{
predecesseur = null;
distance = 0;
parcouru = false;
aPortee = false;
ColorerTuile(Color.white);
}
private void ConsommerAmenagement(TuileManager tuile)
{
if (tuilesAmenageables.Contains(tuile))
{
consommable.amenagement.AmenagerTuile(tuile);
ConsommerConsommable();
}
}
public override void OnInspectorGUI()
{
TuileManager tuileManager = (TuileManager)target;
if (DrawDefaultInspector())
{
}
}
public void RevendiquerTerritoire(TuileManager tuileActuelle, bool revendiquer)
{
RevendiquerTuile(tuileActuelle, revendiquer);
foreach (TuileManager tuile in tuileActuelle.connections)
{
RevendiquerTuile(tuile, revendiquer);
}
}
private void QuandClique()
{
if (controleEstActif)
{
//Gestion du clique gauche
if (Input.GetMouseButtonUp(0))
{
}
//Gestion clique droit
else if (Input.GetMouseButtonUp(1))
{
Collider2D checkTuile = Physics2D.OverlapBox(Camera.main.ScreenToWorldPoint(Input.mousePosition), new Vector2(0.01f, 0.01f), 0, maskTuile);
if (InfoTribus.TribukiJoue && checkTuile && !modeInteraction)
{
TuileManager tuileSelectionnee = checkTuile.GetComponent <TuileManager>();
//On se déplace sur la tuile sur laquelle on a cliqué, si elle est à portée
if (InfoTribus.TribukiJoue.tuilesAPortee.Contains(tuileSelectionnee) && !InfoTribus.TribukiJoue.estEntreCampement)
{
InfoTribus.TribukiJoue.Destination = tuileSelectionnee;
}
else if (InfoTribus.TribukiJoue.estEntreCampement)
{
InfoTribus.TribukiJoue.EntrerCampement(false);
}
}
}
//Gestion clique milieux
else if (Input.GetMouseButtonDown(2))
{
pointAccrocheSouris = Camera.main.ScreenToWorldPoint(Input.mousePosition);
camControle.sourisAccrochee = true;
}
else if (Input.GetMouseButtonUp(2))
{
camControle.sourisAccrochee = false;
}
}
if (modeInteraction)
{
//Quand on fait un clique droit et qu'on clique pas sur un enfant de l'interaction, on sort de l'interaction
//if (Input.GetMouseButtonUp(1))
//{
// Collider2D check = Physics2D.OverlapBox(Camera.main.ScreenToWorldPoint(Input.mousePosition), new Vector2(0.01f, 0.01f), 0);
// if (check == null ||
// check.GetComponentInParent<Interaction>() == null ||
// check.GetComponentInParent<Interaction>() != interactionEnCours)
// {
// ActiverModeInteraction(interactionEnCours, false);
// }
//}
}
}
//algo de Dijkstra
public Stack <TuileManager> TrouverCheminPlusCourt(TuileManager tuileDepart, TuileManager tuileCible)
{
ReinitGraphe(); // Juste par sécurité
List <TuileManager> graphe = new List <TuileManager>(FindObjectsOfType <TuileManager>());
TuileManager tuileObservee;
//Retire les tuiles qui sont déjà occupées et donc infranchissables
List <TuileManager> listeTampon = new List <TuileManager>(graphe);
foreach (TuileManager noeud in graphe)
{
if (noeud.estOccupee)
{
listeTampon.Remove(noeud);
}
}
graphe = listeTampon;
graphe.Add(tuileDepart);
graphe.Add(tuileCible);
//On initialise toutes les distance à infini sauf la tuile de départ
for (int i = 0; i < graphe.Count; i++)
{
graphe[i].distance = Mathf.Infinity;
}
tuileDepart.distance = 0;
while (graphe.Count > 0)
{
tuileObservee = trouverTuileConnectPlusProche(graphe);
if (!tuileObservee)
{
Debug.LogError("Pourquoi la tuile observée est null ?");
}
graphe.Remove(tuileObservee);
//On met à jour les distances
for (int i = 0; i < tuileObservee.connections.Count; i++)
{
TuileManager connection = tuileObservee.connections[i];
if (connection.distance > tuileObservee.distance +
tuileObservee.connectionsDistance[i])
{
connection.distance = tuileObservee.distance +
tuileObservee.connectionsDistance[i];
connection.predecesseur = tuileObservee;
}
}
}
return(TrouverChemin(tuileDepart, tuileCible));
}
public int RecupIndexConnection(TuileManager connection)
{
for (int i = 0; i < connections.Count; i++)
{
if (connections[i] == connection)
{
return(i);
}
}
return(-1);
}
public TuileManager[] TrouverTuilesParColonne(int indexColonne)
{
TuileManager[,] damier = Damier;
TuileManager[] retour = new TuileManager[damier.GetLength(1)];
for (int i = 0; i < damier.GetLength(1); i++)
{
retour[i] = damier[indexColonne, i];
}
return(retour);
}
public TuileManager[] TrouverTuilesParLigne(int indexLigne)
{
TuileManager[,] damier = Damier;
TuileManager[] retour = new TuileManager[damier.GetLength(0)];
for (int i = 0; i < damier.GetLength(0); i++)
{
retour[i] = damier[i, indexLigne];
}
return(retour);
}
public void GenDamier(MappeSysteme.Mappe mappe)
{
colonnes = mappe.colonnes;
lignes = mappe.lignes;
ClearDamier(true);
TuileManager[,] damierTuiles = new TuileManager[mappe.colonnes, mappe.lignes];
int col = 0;
int ligne = -1;
float tailleTuileX = tuileHexa.GetComponent <SpriteRenderer>().bounds.size.x;
float tailleTuileY = tuileHexa.GetComponent <SpriteRenderer>().bounds.size.y;
Vector3 positionTuile = new Vector3();
for (int i = 0; i < mappe.colonnes * mappe.lignes; i++)
{
if (i % mappe.colonnes != 0)
{
col++;
}
else if (ligne <= mappe.lignes)
{
col = 0;
ligne++;
}
positionTuile.x = col * tailleTuileX + ((tailleTuileX / 2) * (ligne % 2));
positionTuile.y = ligne * (tailleTuileY / 4 * 3);
positionTuile.z = ligne * 0.01f;
GameObject nvlTuile = Instantiate(tuileHexa, transform);
nvlTuile.transform.position += positionTuile;
damierTuiles[col, ligne] = nvlTuile.GetComponent <TuileManager>();
damierTuiles[col, ligne].SetTerrain(mappe.mappeTerrains[col, ligne]);
}
foreach (TuileManager tuile in damierTuiles)
{
tuile.Init();
}
damier = RecupDamier();
RenommerTuilesDamier();
damierFleuve.GenererDamierFleuve(mappe);
}
public List <TuileManager> CreerGrapheTuilesAPortee(TuileManager tuileOrigine, float portee, bool peutEmbarquer)
{
ReinitGraphe();
List <TuileManager> grapheAPortee = new List <TuileManager>();
Queue <TuileManager> fileTuiles = new Queue <TuileManager>();
fileTuiles.Enqueue(tuileOrigine);
tuileOrigine.parcouru = true;
//Parcours en largeur (BFS)
while (fileTuiles.Count > 0)
{
TuileManager tuileObservee = fileTuiles.Dequeue();
tuileObservee.EstAPortee();
if (tuileObservee.distance < portee)
{
for (int i = 0; i < tuileObservee.connections.Count; i++)
{
if (tuileObservee.connections[i] != null)
{
TuileManager tuileFille = tuileObservee.connections[i];
if (!tuileFille.parcouru && tuileFille.estOccupee == false) //On demande si la tuile a déjà été explorée par l'algo et si elle est occupée
{
if (peutEmbarquer) // si on peut embarquer, aucune restriction concernant l'eau
{
tuileFille.parcouru = true;
tuileFille.predecesseur = tuileObservee;
tuileFille.distance += tuileObservee.connectionsDistance[i] + tuileObservee.distance;
fileTuiles.Enqueue(tuileFille);
grapheAPortee.Add(tuileFille);
}
else if (!tuileFille.terrainTuile.ettendueEau)// si on ne peut peux pas embarquer, alors l'algo ne prend pas en compte les tuiles d'eau
{
tuileFille.parcouru = true;
tuileFille.predecesseur = tuileObservee;
tuileFille.distance += tuileObservee.connectionsDistance[i] + tuileObservee.distance;
fileTuiles.Enqueue(tuileFille);
grapheAPortee.Add(tuileFille);
}
}
}
}
}
}
return(grapheAPortee);
}
public Vector2Int RecupererCoordonneesTuile(TuileManager tuile)
{
string nomTuile = tuile.gameObject.name;
int x;
int y;
nomTuile = nomTuile.Remove(0, "Tuile".Length);
string[] coordonnees = nomTuile.Split(':');
x = int.Parse(coordonnees[0]);
y = int.Parse(coordonnees[1]);
return(new Vector2Int(x, y));
}
private TuileManager trouverTuileConnectPlusProche(List <TuileManager> graphe)
{
float minim = Mathf.Infinity;
TuileManager sommet = null;
for (int i = 0; i < graphe.Count; i++)
{
if (graphe[i].distance < minim)
{
minim = graphe[i].distance;
sommet = graphe[i];
}
}
return(sommet);
}
// Génère le chemin à partir du graphe de "prédécesseur" créé par la fonction CreerGrapheTuilesAPortee() et TrouverCheminPlusCourt()
public Stack <TuileManager> TrouverChemin(TuileManager tuileOrigine, TuileManager tuileCible)
{
Stack <TuileManager> chemin = new Stack <TuileManager>();
if (tuileCible.predecesseur != null)//Ne calcule ce faisant pas une tuile cible si elle n'est pas à portée.
{
TuileManager tuileObservee = tuileCible;
while (tuileObservee != tuileOrigine)
{
chemin.Push(tuileObservee);
tuileObservee = tuileObservee.predecesseur;
}
}
return(chemin);
}
/// <summary>
/// Marche pas, faut pas l'utiliser
/// </summary>
/// <param name="coordonneesDeb"></param>
/// <param name="coordonneesFin"></param>
/// <returns></returns>
public TuileManager[] TrouverTuilesParEtendue(Vector2Int coordonneesDeb, Vector2Int coordonneesFin)
{
TuileManager[,] damier = Damier;
TuileManager[] retour = new TuileManager[(coordonneesFin.x - coordonneesDeb.x) * (coordonneesFin.y - coordonneesDeb.y)];
int index = 0;
for (int i = coordonneesDeb.y; i < coordonneesFin.y; i++)
{
for (int j = coordonneesDeb.x; j < coordonneesFin.x; j++)
{
retour[index] = damier[j, i];
index++;
}
}
return(retour);
}
public TuileManager[] TrouverTuilesParEtendue(int minX, int minY, int maxX, int maxY)
{
TuileManager[,] damier = Damier;
TuileManager[] retour = new TuileManager[(maxX - minX) * (maxY - minY)];
int index = 0;
for (int i = minY; i < maxY; i++)
{
for (int j = minX; j < maxX; j++)
{
retour[index] = damier[j, i];
index++;
}
}
return(retour);
}
public void Fuire(TuileManager tuileOpposee)
{
jetonAttaque = false;
Vector2 direction = transform.position - (tuileOpposee.transform.position - transform.position);
LayerMask maskTuile = LayerMask.GetMask("Tuile");
RaycastHit2D ray = Physics2D.Raycast(transform.position, direction);
if (ray)
{
TuileManager tuileCible = ray.collider.GetComponent <TuileManager>();
if (!tuileCible.estOccupee || !tuileCible.terrainTuile.ettendueEau)
{
StartCoroutine(Fuire(direction));
}
}
}
private TuileManager[,] RecupDamier()
{
TuileManager[,] damier = new TuileManager[colonnes, lignes];
TuileManager[] damierRef = GetComponentsInChildren <TuileManager>();
int index = 0;
for (int y = 0; y < lignes; y++)
{
for (int x = 0; x < colonnes; x++)
{
damier[x, y] = damierRef[index];
damierRef[index].transform.SetSiblingIndex(index);
index++;
}
}
return(damier);
}
private void RevendiquerTuile(TuileManager tuile, bool revendiquer)
{
if (revendiquer)
{
if (!tuile.revendication.revendicateurs.Contains(this))
{
tuile.revendication.revendicateurs.Add(this);
tuilesRevendiquees.Add(tuile.revendication);
}
}
else
{
if (tuile.revendication.revendicateurs.Contains(this))
{
tuile.revendication.revendicateurs.Remove(this);
tuilesRevendiquees.Remove(tuile.revendication);
}
}
}
private void PlacerPion()
{
if (typePionAAjouter != null)
{
foreach (GameObject go in Selection.gameObjects)
{
TuileManager tuile = go.GetComponentInParent <TuileManager>();
if (tuile != null && tuile.terrainTuile.GetType() != typeof(TerrainCote))
{
if (typePionAAjouter == typeof(Tribu))
{
InfoTribus.AjouterTribu(tuile.transform.position);
}
DesactiverPlacementPion();
break;
}
}
Deselection();
}
}
//Génère le graphe de toutes les tuiles à portée
public List <TuileManager> CreerGrapheTuilesAPortee(TuileManager tuileOrigine, float portee)
{
ReinitGraphe();
List <TuileManager> grapheAPortee = new List <TuileManager>();
Queue <TuileManager> fileTuiles = new Queue <TuileManager>();
fileTuiles.Enqueue(tuileOrigine);
tuileOrigine.parcouru = true;
//Parcours en largeur (BFS)
while (fileTuiles.Count > 0)
{
TuileManager tuileObservee = fileTuiles.Dequeue();
tuileObservee.EstAPortee();
if (tuileObservee.distance < portee)
{
for (int i = 0; i < tuileObservee.connections.Count; i++)
{
if (tuileObservee.connections[i] != null)
{
TuileManager tuileFille = tuileObservee.connections[i];
if (!tuileFille.parcouru && tuileFille.estOccupee == false)//On demande si la tuile a déjà été explorée par l'algo et si elle est occupée
{
tuileFille.parcouru = true;
tuileFille.predecesseur = tuileObservee;
tuileFille.distance += tuileObservee.connectionsDistance[i] + tuileObservee.distance;
fileTuiles.Enqueue(tuileFille);
grapheAPortee.Add(tuileFille);
}
}
}
}
}
return(grapheAPortee);
}
//Gestion de l'overing
private void SourisSurvol()
{
Collider2D checkTuile = Physics2D.OverlapBox(Camera.main.ScreenToWorldPoint(Input.mousePosition), new Vector2(0.01f, 0.01f), 0, maskTuile);
if (controleEstActif)
{
if (checkTuile && InfoTribus.TribukiJoue)
{
TuileManager tuileSurvolee = checkTuile.GetComponent <TuileManager>();
//Colore le chemin et le met à jour toutes les frames, si la tuile qu'on survole est à portee
if (tuileSurvolee.aPortee)
{
if (!InfoTribus.TribukiJoue.estEntreCampement && controleEstActif)
{
InfoTribus.TribukiJoue.pathFinder.ColorerChemin(InfoTribus.TribukiJoue.pathFinder.
TrouverChemin(InfoTribus.TribukiJoue.tuileActuelle, tuileSurvolee), tuileSurvolee.couleurTuileSurChemin);
}
}
}
}
}
private void TrouverTuilesAmenageables()
{
string messageAlerte = "\n<color=#" + ColorUtility.ToHtmlStringRGBA(ListeCouleurs.Defaut.couleurAlerteTexteInterface)
+ ">Aucune tuile à portée ne peut être aménager<color=\"white\">";
tuilesAmenageables.Clear();
for (int i = 0; i < InfoTribus.TribukiJoue.revendication.tuilesRevendiquees.Count; i++)
{
TuileManager tuile = InfoTribus.TribukiJoue.revendication.tuilesRevendiquees[i].tuile;
if (consommable.amenagement.terrainsAmenageables.Contains(tuile.terrainTuile.nom))
{
if (tuile != InfoTribus.TribukiJoue.tuileActuelle)
{
if ((tuile.tuileAmenagement.Amenagement == consommable.amenagement && !tuile.tuileAmenagement.amenagementEstActif) ||
tuile.tuileAmenagement.Amenagement == null)
{
tuilesAmenageables.Add(InfoTribus.TribukiJoue.revendication.tuilesRevendiquees[i].tuile);
}
}
}
}
if (tuilesAmenageables.Count > 0)
{
if (infobulle.texteInfoBulle.Contains(messageAlerte))
{
infobulle.texteInfoBulle = infobulle.texteInfoBulle.Remove(infobulle.texteInfoBulle.IndexOf(messageAlerte), messageAlerte.Length);
}
}
else
{
if (!infobulle.texteInfoBulle.Contains(messageAlerte))
{
iconeConsommable.GetComponent <InfoBulle>().texteInfoBulle += messageAlerte;
}
}
}
public TuileManager[] RecupTuilesFrontalieres()
{
TuileManager[] retour = new TuileManager[2 * lignes + 2 * colonnes];
int index = 0;
TuileManager[] premierLigne = TrouverTuilesParLigne(0);
TuileManager[] derniereLigne = TrouverTuilesParLigne(lignes - 1);
TuileManager[] premiereColonne = TrouverTuilesParColonne(0);
TuileManager[] derniereColonne = TrouverTuilesParColonne(colonnes - 1);
while (index < retour.Length)
{
if (index < premierLigne.Length)
{
retour[index] = premierLigne[index];
}
else if (index < derniereLigne.Length + premierLigne.Length)
{
retour[index] = derniereLigne[index - premierLigne.Length];
}
else if (index < premiereColonne.Length + derniereLigne.Length + premierLigne.Length)
{
retour[index] = premiereColonne[index - (derniereLigne.Length + premierLigne.Length)];
}
else
{
retour[index] = derniereColonne[index - (premiereColonne.Length + derniereLigne.Length + premierLigne.Length)];
}
index++;
}
return(retour);
}
public void SpawnPillard()
{
GameObject pillard = ListeAnimaux.Defaut.pillard;
TuileManager[] tuilesFront = DamierGen.Actuel.RecupTuilesFrontalieres();
List <TuileManager> piocheTuile = new List <TuileManager>();
foreach (TuileManager tuile in tuilesFront)
{
if (!tuile.estOccupee)
{
piocheTuile.Add(tuile);
}
}
if (piocheTuile.Count > 0)
{
TuileManager tuileSpawn = piocheTuile[Random.Range(0, piocheTuile.Count - 1)];
Vector3 positionSpawn = tuileSpawn.transform.position;
positionSpawn.z = -3.5f;
Pillard nvPillard = Instantiate(pillard, positionSpawn, new Quaternion()).GetComponent <Pillard>();
Hostile pillardHost = nvPillard.GetComponent <Hostile>();
int min;
int max;
Guerrier[] guerriers = FindObjectsOfType <Guerrier>();
int ptAtt = 0;
int ptDef = 0;
for (int i = 0; i < guerriers.Length; i++)
{
ptAtt += guerriers[i].attaque;
ptDef += guerriers[i].defense;
}
if (pillardHost.attaqueMin == -1)
{
min = ptAtt / guerriers.Length;
}
else
{
min = pillardHost.attaqueMin;
}
if (pillardHost.attaqueMax == -1)
{
max = ptAtt / guerriers.Length + 2;
}
else
{
max = pillardHost.attaqueMax;
}
pillardHost.attaque = Random.Range(min, max);
if (pillardHost.defenseMin == -1)
{
min = ptDef / guerriers.Length;
}
else
{
min = pillardHost.defenseMin;
}
if (pillardHost.defenseMax == -1)
{
max = ptDef / guerriers.Length + 1;
}
else
{
max = pillardHost.defenseMax;
}
pillardHost.defense = Random.Range(min, max);
Tribu[] tribus = FindObjectsOfType <Tribu>();
List <Demographie> demographies = new List <Demographie>();
foreach (Tribu tribu in tribus)
{
demographies.Add(tribu.demographie);
}
int popTotale = 0;
for (int i = 0; i < demographies.Count; i++)
{
popTotale += demographies[i].taillePopulation;
}
if (pillardHost.nbrCombattantMin == -1)
{
min = popTotale / demographies.Count;
}
else
{
min = pillardHost.nbrCombattantMin;
}
if (pillardHost.nbrCombattantMax == -1)
{
max = popTotale / demographies.Count + 2;
}
else
{
max = pillardHost.nbrCombattantMax;
}
pillardHost.nbrCombattant = Random.Range(min, max);
nvPillard.name = "Pillard";
CameraControle.Actuel.CentrerCamera(nvPillard.transform.position);
}
}
public void SpawnLoup()
{
GameObject Loup = null;
foreach (GameObject predateur in ListeAnimaux.Defaut.Predateurs)
{
if (predateur.name == "Loup")
{
Loup = predateur;
break;
}
}
TuileManager[] tuilesFront = DamierGen.Actuel.RecupTuilesFrontalieres();
List <TuileManager> piocheTuile = new List <TuileManager>();
foreach (TuileManager tuile in tuilesFront)
{
if (!tuile.estOccupee)
{
piocheTuile.Add(tuile);
}
}
if (piocheTuile.Count > 0)
{
TuileManager tuileSpawn = piocheTuile[Random.Range(0, piocheTuile.Count - 1)];
if (Loup)
{
Vector3 positionSpawn = tuileSpawn.transform.position;
positionSpawn.z = -3.5f;
Hostile nvHostile = Instantiate(Loup, positionSpawn, new Quaternion()).GetComponent <Hostile>();
int min;
int max;
Guerrier[] guerriers = FindObjectsOfType <Guerrier>();
int ptAtt = 0;
int ptDef = 0;
for (int i = 0; i < guerriers.Length; i++)
{
ptAtt += guerriers[i].attaque;
ptDef += guerriers[i].defense;
}
if (nvHostile.attaqueMin == -1)
{
min = ptAtt / guerriers.Length;
}
else
{
min = nvHostile.attaqueMin;
}
if (nvHostile.attaqueMax == -1)
{
max = ptAtt / guerriers.Length + 1;
}
else
{
max = nvHostile.attaqueMax;
}
nvHostile.attaque = Random.Range(min, max);
if (nvHostile.defenseMin == -1)
{
min = ptDef / guerriers.Length;
}
else
{
min = nvHostile.defenseMin;
}
if (nvHostile.defenseMax == -1)
{
max = ptDef / guerriers.Length + 1;
}
else
{
max = nvHostile.defenseMax;
}
nvHostile.defense = Random.Range(min, max);
Tribu[] tribus = FindObjectsOfType <Tribu>();
List <Demographie> demographies = new List <Demographie>();
foreach (Tribu tribu in tribus)
{
demographies.Add(tribu.demographie);
}
int popTotale = 0;
for (int i = 0; i < demographies.Count; i++)
{
popTotale += demographies[i].taillePopulation;
}
if (nvHostile.nbrCombattantMin == -1)
{
min = popTotale / demographies.Count;
}
else
{
min = nvHostile.nbrCombattantMin;
}
if (nvHostile.nbrCombattantMax == -1)
{
max = popTotale / demographies.Count + 2;
}
else
{
max = nvHostile.nbrCombattantMax;
}
nvHostile.nbrCombattant = Random.Range(min, max);
nvHostile.name = "Loup";
CameraControle.Actuel.CentrerCamera(nvHostile.transform.position);
}
else
{
Debug.LogError("Y a pas de Loup dans la liste des animaux !!!");
}
}
}
