/// <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);
}
