/// <summary> /// Coupe un soutien à l'aide de l'ordre d'attaque donné. /// </summary> /// <param name="ordre">Ordre à appliquer.</param> private void CoupeSoutien(Attaquer ordre) { OrdreRegional ordreRegional = this.Dictionnaire[ordre.Region]; OrdreRegional ordreRegionalCoupe = this.Dictionnaire[ordre.RegionAttaquee]; if (ordreRegionalCoupe.TypeOrdre != EOrdre.Attaque && ordreRegionalCoupe.TypeOrdre != EOrdre.Tenir) { OrdreRegional ordreRegionalSoutenu = this.Dictionnaire[ordreRegionalCoupe.RegionCiblee]; if (ordreRegionalCoupe.TypeOrdre == EOrdre.SoutienDefensif) { ordreRegionalCoupe.TypeOrdre = EOrdre.SoutienDefensifCoupe; this.Dictionnaire[ordreRegionalCoupe.RegionCiblee].ForceDefensive--; } else if (ordreRegionalCoupe.TypeOrdre == EOrdre.SoutienOffensif && ordreRegionalSoutenu.RegionCiblee != ordreRegional.Region) { ordreRegionalCoupe.TypeOrdre = EOrdre.SoutienOffensifCoupe; this.Dictionnaire[ordreRegionalCoupe.RegionCiblee].ForceOffensive--; } else { // Rien à faire. } } }
/// <summary> /// Enregistre un ordre d'attaque. /// </summary> /// <param name="ordre">Ordre à enregistrer dans le dictionnaire.</param> public void EnregistreAttaque(Attaquer ordre) { this.ForceDefensive = 1; this.ForceOffensive = 1; this.TypeOrdre = EOrdre.Attaque; this.RegionCiblee = ordre.RegionAttaquee; this.TypeUnite = ordre.Unite; this.Possesseur = ordre.Belligerant; }
/// <summary> /// Retourne l'ordre associé au contrôle. /// </summary> /// <returns>Ordre associé au contrôle.</returns> public OrdreAbstrait RetourneOrdre() { String[] ordre = this.Ordre.Text.Split(' '); String regionConcernee = this.region.Text; EUnite unite = Convertisseurs.DepuisEUniteAbrege(this.Unite.Text); EBelligerant belligerant = Convertisseurs.DepuisEBelligerantAbrege(this.Belligerant.Text); if (ordre[0] == "-") { String regionAttaquee = ordre[1]; Attaquer attaque = new Attaquer(unite, belligerant, regionConcernee, regionAttaquee); return(attaque); } else if (ordre[0] == "c") { String regionAttaquante = ordre[1]; String regionAttaquee = ordre[3]; Convoyer convoi = new Convoyer(belligerant, regionConcernee, regionAttaquante, regionAttaquee); return(convoi); } else if (ordre[0] == "s") { if (ordre.Length < 4) { String regionSoutenue = ordre[1]; SoutenirDefensif soutieDefensif = new SoutenirDefensif(unite, belligerant, regionConcernee, regionSoutenue); return(soutieDefensif); } else { String regionAttaquante = ordre[1]; String regionAttaquee = ordre[3]; SoutenirOffensif soutienOffensif = new SoutenirOffensif( unite, belligerant, regionConcernee, regionAttaquante, regionAttaquee); return(soutienOffensif); } } else { Tenir tenir = new Tenir(unite, belligerant, regionConcernee); return(tenir); } }
/// <summary> /// Marque les régions dans lesquelles les unités seront amenées à faire retraite. /// </summary> /// <param name="ordre">Ordre à appliquer.</param> private void MarqueRetraite(Attaquer ordre) { OrdreRegional ordreRegional = this.Dictionnaire[ordre.Region]; if (ordreRegional.TypeOrdre == EOrdre.AttaqueReussie) { OrdreRegional ordreRegionalCible = this.Dictionnaire[ordre.RegionAttaquee]; if (ordreRegionalCible.TypeOrdre != EOrdre.AttaqueReussie) { ordreRegionalCible.Attaquant = ordreRegional.Region; ordreRegionalCible.Retraite = true; } } }
/// <summary> /// Gère les ordres de retraite. /// </summary> /// <param name="ordresRetraites">Liste des ordres de retraite donnés pour le tour.</param> /// <param name="carte">Image représentant la carte.</param> /// <param name="outilsGraphiques">Outils graphiques utilisés pour effectuer le dessin.</param> public void GereRetraites(List <Attaquer> ordresRetraites, Image carte, Graphics outilsGraphiques) { List <OrdreAbstrait> ordresApplicables = new List <OrdreAbstrait>(); foreach (OrdreRegional retraite in this.ListeRetraites) { Attaquer ordreCorrespondant = ordresRetraites.Find(item => item.Region == retraite.Region); if (ordreCorrespondant != null) { if (ordreCorrespondant.RegionAttaquee == retraite.Attaquant) { // Rien n'est à faire. } else { ordresApplicables.Add(ordreCorrespondant as OrdreAbstrait); } } } this.FinitTour(true, ordresApplicables, carte, outilsGraphiques); }
/// <summary> /// Applique un ordre d'attaque. /// </summary> /// <param name="ordre">Ordre à appliquer.</param> private void AppliqueAttaque(Attaquer ordre) { OrdreRegional ordreRegional = this.Dictionnaire[ordre.Region]; OrdreRegional ordreRegionalCible = this.Dictionnaire[ordre.RegionAttaquee]; if (((ordreRegional.ForceOffensive > ordreRegionalCible.ForceDefensive) && (ordreRegional.Possesseur != ordreRegionalCible.Possesseur)) || (ordreRegionalCible.TypeOrdre == EOrdre.AttaqueReussie)) { ordreRegional.TypeOrdre = EOrdre.AttaqueReussie; foreach (OrdreRegional ordreRegionalConcurrent in this.Dictionnaire.Values) { if ((ordreRegionalConcurrent.RegionCiblee == ordreRegional.RegionCiblee) && (ordreRegionalConcurrent.TypeOrdre == EOrdre.AttaqueReussie) && (ordreRegionalConcurrent.Region != ordreRegional.Region)) { if (ordreRegionalConcurrent.ForceOffensive < ordreRegional.ForceOffensive) { ordreRegionalConcurrent.TypeOrdre = EOrdre.AttaqueEchouee; this.ReevalueAttaques(ordreRegionalConcurrent); } else if (ordreRegionalConcurrent.ForceOffensive == ordreRegional.ForceOffensive) { ordreRegional.TypeOrdre = EOrdre.AttaqueEchouee; ordreRegionalConcurrent.TypeOrdre = EOrdre.AttaqueEchouee; this.ReevalueAttaques(ordreRegionalConcurrent); } } } this.ReevalueAttaques(ordreRegional); } else { ordreRegional.TypeOrdre = EOrdre.AttaqueEchouee; } }
/// <summary> /// Teste l'adjacence entre deux régions (hors emploi de convoi), en fonction de l'unité mise en jeu. /// </summary> /// <param name="ordreATester">Ordre d'attaque pour lequel il faut tester l'adjacence des régions mises en jeu.</param> /// <returns>Vrai si l'ordre d'attaque est valide et peut être exécuté sans convoi, faux sinon.</returns> private Boolean TesteAdjacencePourAttaque(Attaquer ordreATester) { Boolean valeurARetourner; Region regionAttaquee = this.dictionnaireRegions[ordreATester.RegionAttaquee]; if ((this.dictionnaireAdjacence.DetermineAdjacence(ordreATester.Region, ordreATester.RegionAttaquee) != EAdjacence.NonAdjacent) && (this.dictionnaireAdjacence.DetermineAdjacence(ordreATester.Region, ordreATester.RegionAttaquee) != EAdjacence.AdjacentMer) && ordreATester.Unite == EUnite.Armée) { valeurARetourner = true; } else if ((this.dictionnaireAdjacence.DetermineAdjacence(ordreATester.Region, ordreATester.RegionAttaquee) != EAdjacence.NonAdjacent) && (this.dictionnaireAdjacence.DetermineAdjacence(ordreATester.Region, ordreATester.RegionAttaquee) != EAdjacence.AdjacentTerre) && (ordreATester.Unite == EUnite.Flotte)) { valeurARetourner = true; } else { valeurARetourner = false; } return(valeurARetourner); }
/// <summary> /// Trie l'ensemble des ordres de convoi donnés pour le tour, et retourne ceux qui sont valides. /// </summary> /// <param name="ordresConvoi">Ensemble des ordres de convoi donnés pour le tour.</param> /// <param name="ordresAttaque">Ensemble des ordres d'attaque (partiellement trié) donnés pour le tour.</param> /// <returns>Liste des ordres de convoi valides.</returns> private List <Convoyer> TrieConvoisValides(List <Convoyer> ordresConvoi, List <Attaquer> ordresAttaque) { List <Convoyer> ordresConvoiValides = new List <Convoyer>(); foreach (var convoi in ordresConvoi) { List <String> regionsMaritimesImpliquees = new List <string>(); ordresConvoi.FindAll(item => item.RegionSoutenue == convoi.RegionSoutenue).ForEach(item => regionsMaritimesImpliquees.Add(item.Region)); if (regionsMaritimesImpliquees.Count > 0) { Attaquer essaiOrdre = ordresAttaque.Find(item => item.Region == convoi.RegionSoutenue); Console.WriteLine(essaiOrdre.Region); Boolean essai = this.TesteValiditeConvoi(convoi, regionsMaritimesImpliquees); Console.WriteLine(essai); if ((ordresAttaque.Find(item => item.Region == convoi.RegionSoutenue) != null) && (this.TesteValiditeConvoi(convoi, regionsMaritimesImpliquees) == true)) { // il faut peut-être vérifier que ce machin va bien et tout et tout... ordresConvoiValides.Add(convoi); } else { this.OrdresTenir.Add(new Tenir(convoi.Unite, convoi.Belligerant, convoi.Region)); } } else { this.OrdresTenir.Add(new Tenir(convoi.Unite, convoi.Belligerant, convoi.Region)); } } return(ordresConvoiValides); }