/// <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 Task InitialiserEnvironnementAsync()
{
Client client = GetClientByIdAsync(1).Result;
if (client == null)
{
string[] territoires = new string[] { "Alberta", "Colombie Britannique", "Île-du-Prince-Édouard", "Manitoba", "Nouveau-Brunswick", "Nouvelle-Écosse", "Nunavut", "Ontario", "Québec", "Saskatchewan", "Terre-Neuve-et-Labrador", "Territoires-du-Nord-Ouest", "Yukon" };
foreach (string t in territoires)
{
AddTerritoire(new Territoire(t));
}
Territoire territoire = GetTerritoireByNomAsync("Québec").Result[0];
ClientPersonne client1 = new ClientPersonne("123456789", "g5l 3x8 rimouski", territoire, "ayman", "chafni");
AddClientPersonneAsync(client1);
EmployéRC employérc1 = new EmployéRC("test", "michel", "antoin", "632145789", "g5l 3x8 montréal", 20);
AddEmployéRCAsync(employérc1);
Technicien technicien = new Technicien("test", "bilal", "rami", "457895123", "g5l 3x8 montréal", 24, territoire);
AddTechnicienAsync(technicien);
Compte compte1 = new Compte(ModeFacturation.Annuel, client1, employérc1);
Compte compte2 = new Compte(ModeFacturation.Mensuel, client1, employérc1);
AddCompteAsync(compte1);
AddCompteAsync(compte2);
}
return(new Task(null));
}
/// <summary>
/// Vérifie si les unités sélectionnées peuvent se déplacer sur moveTo et procède au déplacement le cas échéant.
/// Replace les unités à leurs points de départs si ce n'est pas le cas.
/// </summary>
/// <param name="moveTo">Territoire Le territoire sur lequelle déplacer les unités.</param>
public void MoveMultipleUnits(Territoire moveTo)
{
bool canMove = true;
unitesEnum = selectedList.GetEnumerator();
// Si une des unités sélectionnées ne peut pas se déplacer, on annule tout
while (canMove && unitesEnum.MoveNext())
{
if (unitesEnum.Current.FindDestination(moveTo, false) == null)
{
canMove = false;
}
}
if (canMove)
{
foreach (Unite unite in selectedList)
{
unite.MoveUnit(moveTo, false);
}
}
else
{
InvalidPositioning("Une ou plusieurs unité(s) ne peu(ven)t se déplacer sur le territoire sélectionné.");
}
}
/// <summary>
/// Indique si les unités sélectionnées peuvent attaquer ensemble. Pour cela, elles doivent être
/// </summary>
/// <returns>bool true si les unités sont compatibles, false autrement.</returns>
protected bool CanAttackTogether(Territoire toAttack)
{
if (this.GetType().Name == "Bombardier")
{
if (toAttack.unites.Count > 0)
{
// On vérifie pour chaque unité si elle est du même type et stationnée à portée de tire de la cible
foreach (Unite unit in selectedList)
{
if (unit.GetType().Name != "Bombardier")
{
return(false);
}
Bombardier bombardier = unit as Bombardier;
if (!toAttack.GetVoisinsNDegree(3, true, true).Contains(bombardier.territoire))
{
return(false);
}
}
}
}
else // Seuls les bombardiers peuvent poursuivre
{
return(false);
}
return(true);
}
/// <summary>
/// Ajoute un territoire conquis par le joueur.
/// </summary>
/// <param name="territoire">Territoire Le territoire ajouté par le joueur.</param>
public void AddTerritoire(Territoire territoire)
{
if (!territoires.ContainsValue(territoire))
{
territoires.Add(territoire.Num, territoire);
}
}
/// <summary>
/// Retire un territoire perdu par le joueur.
/// </summary>
/// <param name="territoire">Territoire le territoire perdu par le joueur.</param>
public void RemoveTerritoire(Territoire territoire)
{
if (territoires.ContainsValue(territoire))
{
territoires.Remove(territoire.Num);
}
}
public static Prestation_Territoire Join(Prestation prestation, Territoire territoire)
{
var join = new Prestation_Territoire()
{
Prestation = prestation, Territoire = territoire
};
DAO.Persist(join);
return(join);
}
/// <summary>
/// Indique si les unités sélectionnées peuvent attaquer ensemble. Pour cela, elles doivent être
/// </summary>
/// <returns>bool true si les unités sont compatibles, false autrement.</returns>
protected bool CanAttackTogether(Territoire toAttack)
{
if (this.GetType().Name == "Infanterie" || this.GetType().Name == "Tank")
{
// On vérifie pour chaque unité si elle est d'un type compatible (Tank ou Infanterie) et stationnée à la
// frontière de la cible
foreach (Unite unit in selectedList)
{
if (unit.GetType().Name == "Infanterie" || unit.GetType().Name == "Tank")
{
Terrestre terrestre = unit as Terrestre;
// Une des unités sélectionnées n'est pas stationnée à la frontière de la cible
// Si une route maritime qui ne soit pas bloquée ne connecte pas la cible à la base de l'unité
// Elle ne peut attaquer
if (!toAttack.GetVoisinsNDegree(1, true, false).Contains(terrestre.territoire))
{
return(false);
}
}
else // Si l'unité n'est pas une infanterie ou un tank, le groupe ne peut attaquer de façon coordonnées
{
return(false);
}
}
}
else if (this.GetType().Name == "Artillerie")
{
if (toAttack.unites.Count > 1)
{
// On vérifie pour chaque unité si elle est du même type et stationnée à portée de tire de la cible.
foreach (Unite unit in selectedList)
{
if (unit.GetType().Name != "Artillerie")
{
return(false);
}
Artillerie artie = unit as Artillerie;
// Si la cible n'est pas à moins de 3 territoires d'écart l'unité ne peut ouvrir le feu.
if (!toAttack.GetVoisinsNDegree(2, false, true).Contains(artie.territoire))
{
return(false);
}
}
}
}
else // Une DCA ne peut pas attaquer
{
return(false);
}
return(true);
}
private void Ajouter_Click(object sender, EventArgs e)
{
if (txtAdresse.Text == "" || txtAdresse == null)
{
errAdresse.Visible = true;
return;
}
if (txtTelephone.Text == "" || txtTelephone == null)
{
errTelephone.Visible = true;
return;
}
if (txtTerritoire.Text == "" || txtTerritoire == null)
{
errTerritoire.Visible = true;
return;
}
if ((txtRaisonSociale.Text == "" || txtRaisonSociale == null) & ((txtNom.Text == "" || txtNom == null) || (txtPrenom.Text == "" || txtPrenom == null)))
{
errNomVide.Visible = true;
return;
}
if ((txtRaisonSociale.Text != "" & txtRaisonSociale != null) & ((txtNom.Text != "" & txtNom != null) || (txtPrenom.Text != "" & txtPrenom != null)))
{
errNomVide.Visible = true;
return;
}
if (txtRaisonSociale.Text != "" & txtRaisonSociale != null)
{
Territoire territoire = clientService.GetTerritoireByNom(txtTerritoire.Text)[0];
ClientEntreprise client =
clientService.AddClientEntreprise(new ClientEntreprise(txtTelephone.Text, txtAdresse.Text, territoire, txtRaisonSociale.Text));
MessageBox.Show(client.raisonSociale);
AjouterCompte formAjouterCompte = new AjouterCompte(client.Id, clientService, facturationService);
formAjouterCompte.ShowDialog();
}
if (txtNom.Text != "" & txtNom != null)
{
Territoire territoire = clientService.GetTerritoireByNom(txtTerritoire.Text)[0];
ClientPersonne client = clientService.AddClientPersonne(new ClientPersonne(txtTelephone.Text, txtAdresse.Text, territoire, txtNom.Text, txtPrenom.Text));
AjouterCompte formAjouterCompte = new AjouterCompte(client.Id, clientService, facturationService);
formAjouterCompte.ShowDialog();
}
}
/// <param name="territoire1">Territoire Un des territoires que la route connecte.</param>
/// <param name="territoire2">Territoire Un des territoires que la route connecte.</param>
/// <param name="color">Color La couleur de la route pour la reconnaissance.</param>
public Route(Territoire territoire1, Territoire territoire2, Color color)
{
territoires = new List <Territoire>()
{
territoire1,
territoire2
};
couleur = color;
unites = new List <Unite>();
}
public void AddFacture(Compte compte, Installation installation)
{
decimal montantEquipements = 0;
decimal montantServicesDiffusion = 0;
decimal montantFilms = 0;
foreach (Equipement e in compte.equipements)
{
montantEquipements += e.tarifMensuelLocation;
}
Client client = _clientService.GetClientByCompteId(compte.Id);
Territoire territoire = _clientService.GetTerritoireByClientId(client.Id);
IReadOnlyList <EstDesserviDans> est = _clientService.GetEstDesserviDansByTerritoireId(territoire.Id);
foreach (EstDesserviDans e in est)
{
foreach (ServiceDiffusion s in compte.serviceDiffusions)
{
if (s == e.serviceDiffusion)
{
montantServicesDiffusion += e.tarif;
}
}
}
IReadOnlyList <LoueFilm> loues = _clientService.GetLoueFilmDuMois();
List <Film> filmsVus = new List <Film>();
Film film;
foreach (LoueFilm l in loues)
{
film = _clientService.GetFilmByLoueFilm(l.Id);
montantFilms += film.montantLocation;
filmsVus.Add(film);
}
Facture facture;
if (installation == null)
{
facture = new Facture(montantFilms, montantEquipements, montantServicesDiffusion, 0, compte, filmsVus);
}
else
{
facture = new Facture(montantFilms, montantEquipements, montantServicesDiffusion, installation.frais, compte, filmsVus);
}
_clientService.AddFacture(facture);
}
private void Reset()
{
territoireCible = null;
unitAtt = new List <Unite>();
routeCible = null;
unitDef = new List <Unite>();
unitesDetruitesAtt = new int[] { 0, 0, 0, 0, 0, 0, 0 };
unitesDetruitesDef = new int[] { 0, 0, 0, 0, 0, 0, 0 };
subAtt = new List <Submarin>();
joueurAtt = null;
joueurDef = null;
}
/// <summary>
/// Attaque de l'IA lorsqu'il a la main contre les territoires enemies.
/// </summary>
public IEnumerator IAAttack()
{
bool done = false;
step = 3;
// Tant qu'on en a pas terminé
while (!done)
{
// Les territoires dont les unités peuvent attaquer
List <Territoire> territoiresAttaquants = TerritoiresAttaquants();
Territoire toAttack = null;
if (territoiresAttaquants.Count > 0)
{
toAttack = ChoseTarget(territoiresAttaquants);
}
if (toAttack != null)
{
bool attacking = false;
List <Unite> unitToAttack = new List <Unite>();
unitToAttack = GetUnitToAttack(toAttack);
attacking = unitToAttack.Count > 0;
foreach (Unite unite in unitToAttack)
{
unite.selectedList = unitToAttack;
}
// Lancement de l'attaque
if (attacking && unitToAttack.Count > 0)
{
// Debug.Log("Salut ! Tu viens pour l'aventure ? uTA.Count : "+unitToAttack.Count);
yield return(StartCoroutine(battleManager.LaunchAttack(unitToAttack, toAttack)));
// Debug.Log("Mes amis, la porte est ouverte.");
}
else if (territoiresAttaquants.Count < 1)
{
done = true;
}
}
else
{
done = true;
}
yield return(null);
}
}
/// <summary>
/// Ajoute un voisin dans la liste des voisins du territoire et inversement si nécessaire
/// </summary>
/// <param name="voisin">Territoire Le voisin à ajouter</param>
public void AddVoisin(Territoire voisin)
{
// Ajout du voisin dans la liste des voisins
if (!voisins.Contains(voisin))
{
voisins.Add(voisin);
}
// Ajout du territoire dans la liste des voisins du voisin
if (!voisin.Voisins.Contains(this))
{
voisin.AddVoisin(this);
}
}
/// <summary>
/// Fonction permettant d'attaquer un territoire.
/// Cette fonction sera partagée par l'infanterie et le tank et réécrite pour l'artillerie.
/// </summary>
/// <param name="territoire">Territoire Le territoire à attaquer</param>
public override void Attack(Territoire toAttack)
{
if (!toAttack.joueur.Equals(joueur))
{
if (CanAttackTogether(toAttack))
{
battleManager.LaunchAttack(selectedList, toAttack);
}
else
{
InvalidPositioning("Certaines unités ne peuvent attaquer la cible.");
}
}
else
{
InvalidPositioning("Vous ne pouvez attaquer votre propre territoire.");
}
}
private void CmbTerritoire_SelectionChangeCommitted(object sender, EventArgs e)
{
Territoire territoire = clientService.GetTerritoireByNom(cmbTerritoire.SelectedItem.ToString())[0];
errTerritoire.Visible = false;
succesTerritoire.Visible = false;
if (clientService.GetEstDesserviDansByTerritoireId(territoire.Id).Count == 0)
{
errTerritoire.Visible = true;
}
else
{
succesTerritoire.Visible = true;
}
}
/// <summary>
/// Fonction permettant de déplacer l'unité sur le territoire
/// </summary>
/// <param name="moveTo">Territoire Le territoire sur lequel se déplacer</param>
/// <returns>bool true si l'unité a pu se déplacer avec succès, false sinon</returns>
public override void MoveUnit(Territoire moveTo, bool voisinage = false) // TODO À tester
{
Territoire destination = FindDestination(moveTo, voisinage);
if (destination != null)
{
territoire = destination;
territoire.unites.Add(this);
// Les unités qui ne sont pas déployées ne peuvent plus jouer pendant ce tour
if (GameObject.Find("GUIManager").GetComponent <TurnManager>().PhaseActive != TurnManager.phases.Deploiement)
{
Disable();
}
else
{
RemoveSelection();
}
}
}
/// <summary>
/// Fonction permettant de déplacer l'unité sur le territoire
/// </summary>
/// <param name="moveTo">Territoire Le territoire sur lequel se déplacer</param>
/// <returns>bool true si l'unité a pu se déplacer avec succès, false sinon</returns>
public override void MoveUnit(Territoire moveTo, bool voisinage = false) // TODO À tester
{
Territoire destination = FindDestination(moveTo, voisinage);
if (destination != null)
{
territoire = destination;
territoire.unites.Add(this);
// Les unités ne peuvent plus être jouées si elles sont déplacées en-dehors de la phase de déploiement.
if (GameObject.Find("GUIManager").GetComponent <TurnManager>().PhaseActive != TurnManager.phases.Deploiement)
{
Disable();
}
else
{
RemoveSelection();
}
}
}
/// <summary>
/// Fonction permettant d'attaquer un territoire.
/// Cette fonction sera partagée par l'infanterie et le tank et réécrite pour l'artillerie.
/// </summary>
/// <param name="territoire">Territoire Le territoire à attaquer</param>
public override void Attack(Territoire toAttack)
{
if (territoire == null)
{
InvalidPositioning("Vous ne pouvez pas attaquer un territoire sans au préalable déployer votre unité.");
}
else if (toAttack.joueur != joueur)
{
if (CanAttackTogether(toAttack))
{
battleManager.LaunchAttack(selectedList, toAttack);
}
else
{
InvalidPositioning("Certaines unités ne peuvent attaquer la cible.");
}
}
else
{
InvalidPositioning("Vous ne pouvez attaquer votre propre territoire.");
}
}
/// <summary>
/// Retourne moveTo s'il est possible à l'unité de s'y déplacer ou un territoire adjacent si voisinage = true.
/// </summary>
/// <param name="territoire">Territoire Le territoire sur lequel se déplacer</param>
/// <param name="voisinage">bool true pour déplacer l'unité sur un territoire adjacent à moveTo, false pour déplacer l'unité sur moveTo</param>
/// <returns>Territoire Le territoire sur lequel se déplacer si c'est possible, null si aucun ne correspond</returns>
protected virtual Territoire FindDestination(Territoire moveTo, bool voisinage)
{
return(null);
}
public override void Attack(Territoire toAttack)
{
InvalidPositioning("La DCA n'a qu'un rôle défensif et ne peux attaquer un territoire.");
}
/// <summary>
/// Lance l'attaque sur le territoire cible.
/// </summary>
/// <param name="unitAttacking">List(Unite) Les unités donnant l'assaut.</param>
/// <param name="cible">Territoire Le territoire cible.</param>
public IEnumerator LaunchAttack(List <Unite> unitAttacking, Territoire cible)
{
unitAtt = new List <Unite>();
foreach (Unite unite in unitAttacking)
{
unitAtt.Add(unite);
}
//Debug.Log("unitAtt.Count : " + unitAtt.Count);
territoireCible = cible;
joueurAtt = unitAtt[0].Joueur;
joueurDef = territoireCible.joueur;
bool ranged = false;
if (unitAtt[0].GetType().Name == "Artillerie" || unitAtt[0].GetType().Name == "Bombardier")
{
ranged = true;
}
// Récupération des unités présentes sur la cible
foreach (Unite unit in cible.joueur.Unites)
{
if (unit.GetType().BaseType.Name == "Terrestre")
{
Terrestre terrestre = unit as Terrestre;
if (terrestre.territoire.Equals(cible))
{
unitDef.Add(terrestre);
}
}
else if (unit.GetType().BaseType.Name == "Aerienne")
{
Aerienne aerienne = unit as Aerienne;
if (aerienne.territoire.Equals(cible))
{
unitDef.Add(aerienne);
}
}
}
int[] diceAtt = new int[Math.Min(3, unitAtt.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, unitAtt.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, ranged);
// Si toutes les unités de la défense sont détruites, le territoire est conquit
if (unitAtt.Count > 0 && unitDef.Count == 0)
{
territoireCible.joueur.Territoires.Remove(territoireCible.Num);
territoireCible.joueur = joueurAtt;
joueurAtt.Territoires.Add(territoireCible.Num, territoireCible);
territoireCible.unites.Clear();
if (!ranged)
{
foreach (Unite unit in unitAtt)
{
if (unit.GetType().Name == "Infanterie" || unit.GetType().Name == "Tank")
{
Terrestre terrestre = unit as Terrestre;
terrestre.territoire.unites.Remove(terrestre);
terrestre.territoire = territoireCible;
territoireCible.unites.Add(unit);
if (joueurAtt.GetType().Name.Equals("IAEasy") || joueurAtt.GetType().Name.Equals("IAMedium") || joueurAtt.GetType().Name.Equals("IAHard"))
{
terrestre.transform.localPosition = territoireCible.Position;
}
}
}
}
}
else
{
foreach (Unite unit in unitAtt)
{
unit.ResetPosition();
}
if (ranged)
{
foreach (Unite unit in unitAtt)
{
unit.Disable();
}
}
}
////Debug.Log("Ça se voit.");
// Affichage du résultat de l'assaut.
yield return(StartCoroutine(GameObject.Find("GUIManager").GetComponent <GUIController>().ShowAssaultResult(diceAtt, diceDef, unitesDetruitesAtt, unitesDetruitesDef, unitAtt, unitDef)));
//Debug.Log("Eh bien, je frappe pour qu'on vienne nous ouvrir.");
// Réinitialisation des variables pour éviter toute erreur.
Reset();
}
public Territoire AddTerritoire(Territoire territoire)
{
return(_territoireRepository.Add(territoire));
}
/// <summary>
/// Fonction permettant d'attaquer un territoire
/// </summary>
/// <param name="territoire">Territoire Le territoire à attaquer</param>
public virtual void Attack(Territoire territoire)
{
}
/// <summary>
/// Fonction permettant de déplacer l'unité sur moveTo ou un territoire adjacent.
/// </summary>
/// <param name="territoire">Territoire Le territoire sur lequel se déplacer</param>
/// <param name="voisinage">bool true pour déplacer l'unité sur un territoire adjacent à moveTo, false pour déplacer l'unité sur moveTo</param>
public virtual void MoveUnit(Territoire moveTo, bool voisinage)
{
}
protected List <Unite> GetUnitToAttack(Territoire toAttack)
{
List <Territoire> .Enumerator voisins3DegresEnum = toAttack.GetVoisinsNDegree(3, true, true).GetEnumerator();
List <Territoire> .Enumerator voisins2DegresEnum = toAttack.GetVoisinsNDegree(2, false, true).GetEnumerator();
List <Territoire> .Enumerator voisinsEnum = toAttack.GetVoisinsNDegree(1, true, false).GetEnumerator();
bool attacking = false;
List <Unite> unitToAttack = new List <Unite>();
// S'il y a plus d'une unité sur la cible il est possible d'attaquer à distance
if (toAttack.unites.Count > 1)
{
// S'il est possible d'attaquer avec au moins un bombardier on les sélectionne
while (!attacking && voisins3DegresEnum.MoveNext())
{
if (voisins3DegresEnum.Current.joueur.Equals(this))
{
List <Unite> unitesVoisin = voisins3DegresEnum.Current.unites;
attacking = true;
foreach (Unite unit in unitesVoisin)
{
if (unit.GetType().Name == "Bombardier" && unit.canAct)
{
unitToAttack.Add(unit);
unit.selected = true;
}
}
}
}
// Il n'y a pas de bombardier à proximité alors il faut chercher les éventuelles artilleries
if (!attacking)
{
while (!attacking && voisins2DegresEnum.MoveNext())
{
List <Unite> unitesVoisin = voisins2DegresEnum.Current.unites;
attacking = true;
foreach (Unite unit in unitesVoisin)
{
if (unit.GetType().Name == "Artillerie" && unit.canAct)
{
unitToAttack.Add(unit);
unit.selected = true;
}
}
}
}
}
// Il n'y a pas non plus d'artillerie il faut se rabattre sur les unités d'assaut
if (!attacking)
{
while (!attacking && voisinsEnum.MoveNext())
{
// Il s'agit d'un territoire de l'IA dont c'est le tour et plus d'une d'unité y est stationnée
// ces dernières sont ajoutées à la liste de celles partant à l'assaut, sauf une.
if (voisinsEnum.Current.joueur.Equals(this) && voisinsEnum.Current.unites.Count > 1)
{
List <Tank> tanks = new List <Tank>();
List <Infanterie> infanteries = new List <Infanterie>();
foreach (Unite unit in voisinsEnum.Current.unites)
{
if (unit.GetType().Name == "Infanterie")
{
infanteries.Add(unit as Infanterie);
}
else if (unit.GetType().Name == "Tank")
{
tanks.Add(unit as Tank);
}
}
foreach (Tank tank in tanks)
{
if (unitToAttack.Count < voisinsEnum.Current.unites.Count - 1 && tank.canAct)
{
unitToAttack.Add(tank);
tank.selected = true;
}
}
foreach (Infanterie infanterie in infanteries)
{
if (unitToAttack.Count < voisinsEnum.Current.unites.Count - 1 && infanterie.canAct)
{
unitToAttack.Add(infanterie);
infanterie.selected = true;
}
}
if (unitToAttack.Count > 0)
{
attacking = true;
}
}
}
}
return(unitToAttack);
}
public Task AddTerritoireAsync(Territoire territoire)
{
return(_territoireRepository.AddAsync(territoire));
}
void OnMouseUp()
{
if (!guiManager.GetComponent <GUIController>().dialogOpened) // S'il n'y a pas de fenêtre de dialogue d'ouverte
{
if (dragged)
{
dragged = false;
TurnManager.phases phaseActive = guiManager.GetComponent <TurnManager>().PhaseActive;
RaycastHit hit;
// Le Raycast vérifiera si la droite perpendiculaire à la map passant par l'unité touche un territoire
// et donc si l'unité tombera sur un territoire
if (Physics.Raycast(this.transform.position, Vector3.down, out hit, 4.0f, LayerMask.GetMask("BoardLayer")))
{
System.Object zoneSelectionnee = GameObject.Find("Territoires colorés").GetComponent <ColoredTerritories>().GetHoveredTerritory(hit);
if (zoneSelectionnee != null)
{
if (zoneSelectionnee.GetType().Name == "Territoire")
{
Territoire territoireSelectionnee = zoneSelectionnee as Territoire;
// Terrestre terrestre = this as Terrestre;
// if(territoireSelectionnee.Equals(terrestre.territoire))
if (territoireSelectionnee.joueur == joueur)
{
// Les unités peuvent se déplacer pendant la phase de déploiement si elles viennent d'être achetée ou durant la
// phase de mouvement
if (phaseActive != TurnManager.phases.Attaque)
{
MoveMultipleUnits(territoireSelectionnee);
}
else
{
InvalidPositioning("Vous ne pouvez (re)déployer vos unités en-dehors la phase de mouvement ou de déploiement.");
}
}
else
{
if (phaseActive == TurnManager.phases.Attaque)
{
Attack(territoireSelectionnee);
}
else
{
InvalidPositioning("Vous ne pouvez attaquer en-dehors de la phase d'attaque.");
}
}
}
else
{
Route routeSelectionnee = zoneSelectionnee as Route;
if (routeSelectionnee.joueur == joueur || routeSelectionnee.joueur == null)
{
// Les unités peuvent se déplacer pendant la phase de déploiement si elles viennent d'être achetée ou durant la
// phase de mouvement
if (phaseActive != TurnManager.phases.Attaque)
{
MoveMultipleUnits(routeSelectionnee);
}
else
{
InvalidPositioning("Vous ne pouvez redéployer vos unités en-dehors la phase de mouvement.");
}
}
else
{
if (phaseActive == TurnManager.phases.Attaque)
{
Attack(routeSelectionnee);
}
else
{
InvalidPositioning("Vous ne pouvez attaquer en-dehors de la phase d'attaque");
}
}
}
}
else
{
InvalidPositioning("Cette unité ne peut être déployée ici.");
}
}
else
{
foreach (Unite unit in selectedList)
{
unit.transform.position = unit.offset;
}
}
}
}
}
/// <summary>
/// Retourne moveTo s'il est possible à l'unité de s'y déplacer, un territoire adjacent si voisinage = true ou null s'il n'est pas possible de déplacer l'unité.
/// </summary>
/// <param name="territoire">Territoire Le territoire sur lequel se déplacer</param>
/// <param name="voisinage">bool true pour déplacer l'unité sur un territoire adjacent à moveTo, false pour déplacer l'unité sur moveTo</param>
/// <returns>Territoire Le territoire sur lequel se déplacer si c'est possible, null si aucun ne correspond</returns>
protected override Territoire FindDestination(Territoire moveTo, bool voisinage)
{
// L'unité peut encore se déplacer
if (canAct)
{
// Le territoire est au joueur, on peut y stationner l'unité, ou c'est un voisin que l'on cherche
if (moveTo.joueur == joueur || voisinage)
{
// L'unité vient d'être acheté, on la place sur le territoire sélectionné
if (territoire == null)
{
return(moveTo);
}
else // L'unité a déjà été placée
{
bool found = false;
List <Territoire> .Enumerator territoriesEnumerator = territoire.Voisins.GetEnumerator();
// On cherche si le territoire cible est dans le voisinage direct du territoire de départ
while (!found && territoriesEnumerator.MoveNext())
{
if (territoriesEnumerator.Current == moveTo)
{
found = true;
}
}
// On ne l'a pas trouvé alors on voit si la destination est connecté par une route au territoire de départ
if (!found)
{
List <Route> .Enumerator routesEnumerator = territoire.Routes.GetEnumerator();
while (!found && routesEnumerator.MoveNext())
{
List <Territoire> connecteds = routesEnumerator.Current.Territoires;
foreach (Territoire connected in connecteds)
{
// On a trouvé la destination et elle n'est pas bloquée par un barrage maritime, l'unité peut donc s'y déplacer
if (connected == moveTo || routesEnumerator.Current.joueur == joueur || routesEnumerator.Current.joueur == null)
{
found = true;
}
}
}
}
// Toujours pas trouvé ?! Parcours de graphe time !
if (!found && voisinage)
{
// Les territoires à regarder
List <Territoire> toVisit = new List <Territoire> {
territoire
};
List <Territoire> visited = new List <Territoire>(); // Les territoires déjà vus
int i = -1;
// On parcourt maintenant les territoires alliés dans l'ordre de découverte en ajoutant ceux connectés par une route maritime
// qui ne soit pas occupée par un ennemie jusqu'à trouver le territoire ou ne plus pouvoir visiter d'autre territoire
while (!found && i++ < toVisit.Count)
{
// On a trouvé la destination, l'unité peut donc s'y déplacer
if (toVisit[i] == moveTo)
{
// On cherche cependant un territoire allié adjacent
if (voisinage)
{
List <Territoire> .Enumerator enumerator = toVisit[i].Voisins.GetEnumerator();
while (!found && enumerator.MoveNext())
{
if (enumerator.Current.joueur == joueur)
{
return(enumerator.Current);
}
}
InvalidPositioning("Il n'y a pas de territoire adjacent sur lequel placer cette unité.");
return(null);
}
found = true;
}
else
{
visited.Add(toVisit[i]);
// On ajoute les voisins direct du territoire visité s'ils appartiennent au joueur
foreach (Territoire ter in toVisit[i].Voisins)
{
// Le territoire n'est pas celui de départ et n'est ni dans ceux déjà visités ou à visiter
if (ter != territoire && !toVisit.Contains(ter) && !visited.Contains(ter) && ter.joueur == joueur)
{
toVisit.Add(ter);
}
}
// On regarde également les territoires connectés par une route maritime
foreach (Route route in toVisit[i].Routes)
{
// Si la route n'est pas bloquée par un barrage ennemie
if (route.joueur == joueur || route.joueur == null)
{
foreach (Territoire ter in route.Territoires)
{
// Le territoire n'est pas celui de départ et n'est ni dans ceux déjà visités ou à visiter
if (ter != territoire && !toVisit.Contains(ter) && !visited.Contains(ter))
{
toVisit.Add(ter);
}
}
}
}
}
}
}
if (found)
{
return(moveTo);
}
}
}
else
{
InvalidPositioning("Vous ne pouvez placer une unité sur un territoire ennemie");
}
}
else
{
InvalidPositioning("Une ou plusieurs unité(s) sélectionnée(s) ne peu(ven)t plus se déplacer");
}
return(null);
}
public int InitialiserEnvironnement()
{
Client client = GetClientById(1);
if (client == null)
{
string[] territoires = new string[] { "Alberta", "Colombie Britannique", "Île-du-Prince-Édouard", "Manitoba", "Nouveau-Brunswick", "Nouvelle-Écosse", "Nunavut", "Ontario", "Québec", "Saskatchewan", "Terre-Neuve-et-Labrador", "Territoires-du-Nord-Ouest", "Yukon" };
foreach (string t in territoires)
{
AddTerritoire(new Territoire(t));
}
Territoire territoire = GetTerritoireByNom("Québec")[0];
ClientPersonne client1 = AddClientPersonne(new ClientPersonne("123456789", "g5l 3x8 rimouski", territoire, "ayman", "chafni"));
EmployéRC employérc1 = AddEmployéRC(new EmployéRC("test", "michel", "antoin", "632145789", "g5l 3x8 montréal", 20));
Technicien technicien = new Technicien("test", "bilal", "rami", "457895123", "g5l 3x8 montréal", 24, territoire);
AddTechnicien(technicien);
Compte compte1 = new Compte(ModeFacturation.Annuel, client1, employérc1);
Compte compte2 = new Compte(ModeFacturation.Mensuel, client1, employérc1);
List <ServiceDiffusion> services = new List <ServiceDiffusion>();
services.Add(AddServiceDiffusion(new ServiceDiffusion("service de base")));
AddServiceDiffusion(new ServiceDiffusion("service maxi-vue"));
services.Add(AddServiceDiffusion(new ServiceDiffusion("service 911")));
compte1.serviceDiffusions = services;
AddCompte(compte1);
AddCompte(compte2);
AddEquipement(new Equipement(121, "téléviseur", compte1));
AddEquipement(new Equipement(121, "télécommande", compte1));
AddEquipement(new Equipement(121, "décodeur", compte1));
AddEquipement(new Equipement(121, "téléviseur XL", compte1));
EstDesserviDans est = new EstDesserviDans(74, GetTerritoireByNom("Québec")[0], GetServiceByNom("service de base")[0]);
EstDesserviDans est1 = new EstDesserviDans(140, GetTerritoireByNom("Québec")[0], GetServiceByNom("service maxi-vue")[0]);
EstDesserviDans est2 = new EstDesserviDans(74, GetTerritoireByNom("Québec")[0], GetServiceByNom("service 911")[0]);
AddEstDesserviDans(est);
AddEstDesserviDans(est1);
AddEstDesserviDans(est2);
return(0);
}
return(1);
}
