/// <summary>
/// Lit l'ensemble des ordres d'ajustement notés dans les champs d'ordre
/// (phase d'ajustement uniquement).
/// </summary>
/// <returns>Ensemble des ordres d'ajustement donnés pour le tour d'hiver courant.</returns>
private List <Ajuster> LitAjustements()
{
Int32 compteur = 0;
Int32 placesDisponibles = 0;
String belligerant = null;
List <Ajuster> ordresAjustements = new List <Ajuster>();
List <Ajuster> congediementTemporaires = new List <Ajuster>();
foreach (ChampOrdre ordre in this.metaChampOrdre.ChampsOrdres)
{
Ajuster ordreAjustement = ordre.RetourneAjustement();
congediementTemporaires.Add(ordreAjustement);
if (ordre.NomBelligerant != belligerant)
{
this.TraqueUnitesSuperfetatoires(compteur, placesDisponibles, congediementTemporaires, ordresAjustements);
congediementTemporaires.Clear();
belligerant = ordre.NomBelligerant;
compteur = 0;
String nomCompletBelligerant = Convertisseurs.DepuisEBelligerantAbrege(ordre.NomBelligerant).ToString();
placesDisponibles = this.nombreCentres[nomCompletBelligerant] - this.nombreUnites[nomCompletBelligerant];
}
if (((ordreAjustement.Recrutement == EAjustement.Recrutement) && (compteur < placesDisponibles)) ||
(ordreAjustement.Recrutement == EAjustement.Congédiement))
{
ordresAjustements.Add(ordreAjustement);
compteur++;
}
}
this.TraqueUnitesSuperfetatoires(compteur, placesDisponibles, congediementTemporaires, ordresAjustements);
return(ordresAjustements);
}
/// <summary>
/// Classe les deux champs selon un ordre total (par belligérants, unité, et territoire).
/// </summary>
/// <param name="premierChamp">L'un des deux champs à comparer.</param>
/// <param name="secondChamp">L'un des deux champs à comparer.</param>
/// <returns>Valeur négative si premierChamp est avant premierChamp, et positive dans le cas opposé.</returns>
public static Int32 ClasseChampsOrdres(ChampOrdre premierChamp, ChampOrdre secondChamp)
{
if (premierChamp.NomBelligerant != secondChamp.NomBelligerant)
{
EBelligerant premierBelligerant = Convertisseurs.DepuisEBelligerantAbrege(premierChamp.NomBelligerant);
EBelligerant secondBelligerant = Convertisseurs.DepuisEBelligerantAbrege(secondChamp.NomBelligerant);
return(Convertisseurs.ClasseEBelligerants(premierBelligerant, secondBelligerant));
}
else
{
if (premierChamp.NomUnite != secondChamp.NomUnite)
{
if (premierChamp.NomUnite == "A")
{
return(-1);
}
else
{
return(1);
}
}
else
{
Int32 triAlphabetique = String.Compare(premierChamp.NomRegion, secondChamp.NomRegion);
return(triAlphabetique);
}
}
}
/// <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>
/// Change arbitrairement l'allégeance d'une unité sur la carte.
/// </summary>
/// <param name="identificateurBelligerant">Belligérant prenant possession de l'unité.</param>
/// <param name="nomRegion">Nom de la région où l'unité change d'allégeance.</param>
/// <param name="carte">Image représentant la carte.</param>
/// <param name="outilsGraphiques">Outils graphiques utilisés pour effectuer le dessin.</param>
public void ChangeAllegeanceUnite(String identificateurBelligerant, String nomRegion, Image carte, Graphics outilsGraphiques)
{
if (this.DictionnaireOccupation.Keys.Contains(nomRegion) == true)
{
EUnite unite = this.DictionnaireOccupation[nomRegion].TypeUnite;
EBelligerant belligerantConcerne = Convertisseurs.VersEBelligerant(identificateurBelligerant);
this.DictionnaireOccupation[nomRegion].ChangeUnite(unite, belligerantConcerne);
Pictogrammes.PlaceUnite(this.DictionnaireRegions[nomRegion], this.DictionnaireOccupation[nomRegion], carte, outilsGraphiques);
}
else
{
throw new Exception("L'allégeance et/ou le nom de la région sont mal définis.");
}
}
/// <summary>
/// Réinitialise la carte et les champs d'ordres.
/// </summary>
private void Reinitialise(String ordres)
{
if (this.estInitialise == true)
{
this.InitialiseCarte();
this.CreeChampsOrdres(ordres);
/// Affichage de la date et de la phase
this.emplacementDate.Visible = true;
this.emplacementDate.Text = this.conteneurDonnees.PeriodeCourante.ToString();
this.emplacementPhase.Visible = true;
this.emplacementPhase.Text = Convertisseurs.VersPhaseJeuAbregee(this.conteneurDonnees.PhaseCourante);
}
}
/// <summary>
/// Crée les champs d'ordres correspondant aux ajustements, et les place de manière adéquate.
/// </summary>
/// <param name="nombreCentres">Nombre de centres par belligérants.</param>
/// <param name="nombreUnites">Nombre d'unités par belligérants.</param>
/// <param name="dictionnaireRegions">Dictionnaire des régions correspondant à la carte.</param>
/// <param name="dictionnaireOccupation">Dictionnaire d'occupation correspondant à la partie courante.</param>
/// <param name="dictionnaireRecrutement">Dictionnaire des lieux de recrutement autorisés.</param>
public void CreeChampsOrdres_Ajustements(
Dictionary <String, Int32> nombreCentres,
Dictionary <String, Int32> nombreUnites,
Dictionary <String, GRegion> dictionnaireRegions,
Dictionary <String, OccupationRegion> dictionnaireOccupation,
Dictionary <EBelligerant, List <String> > dictionnaireRecrutement)
{
foreach (String nomBelligerant in nombreCentres.Keys)
{
EBelligerant belligerantCourant = Convertisseurs.VersEBelligerant(nomBelligerant);
if (nombreCentres[nomBelligerant] > nombreUnites[nomBelligerant])
{
foreach (String region in dictionnaireRecrutement[belligerantCourant])
{
OccupationCentre centre = dictionnaireOccupation[region] as OccupationCentre;
if (centre.TypeUnite == EUnite.Aucune && centre.PossesseurCentre == belligerantCourant)
{
Boolean regionCotiere = (dictionnaireRegions[region].TypeRegion == ETypeRegion.Côtière) ? true : false;
String nomBelligerantAbrege = Convertisseurs.VersEBelligerantAbrege(belligerantCourant);
this.ChampsOrdres.Add(new ChampOrdre(regionCotiere, nomBelligerantAbrege, region));
}
}
}
else if (nombreCentres[nomBelligerant] < nombreUnites[nomBelligerant])
{
foreach (OccupationRegion regionOccupee in dictionnaireOccupation.Values)
{
if ((regionOccupee.TypeUnite != Geographie.Enumerations.EUnite.Aucune) && (regionOccupee.PossesseurUnite == belligerantCourant))
{
String nomBelligerantAbrege = Convertisseurs.VersEBelligerantAbrege(belligerantCourant);
String typeUnite = Geographie.Convertisseurs.VersEUniteAbrege(regionOccupee.TypeUnite);
String nomRegion = regionOccupee.Region;
this.ChampsOrdres.Add(new ChampOrdre(nomBelligerantAbrege, typeUnite, nomRegion));
}
}
}
}
this.CreeChampsOrdres_General();
}
/// <summary>
/// Dessine le drapeau associé au belligérant.
/// </summary>
private void DessineDrapeau()
{
Graphics outilsGraphiques = Graphics.FromImage(this.drapeauInterne);
Pen traceurContour = new Pen(Color.Black, 2);
Geographie.Enumerations.EBelligerant nationalite = Geographie.Convertisseurs.DepuisEBelligerantAbrege(this.NomBelligerant);
if (nationalite == Geographie.Enumerations.EBelligerant.Palavin)
{
traceurContour = new Pen(Color.Red, 2);
}
outilsGraphiques.DrawRectangle(traceurContour, 0, 0, this.emplacementDrapeau.Width, this.emplacementDrapeau.Height);
Color couleur = Convertisseurs.VersCouleur(nationalite);
Brush traceur = new SolidBrush(couleur);
outilsGraphiques.FillRectangle(traceur, 1, 1, this.emplacementDrapeau.Width - 2, this.emplacementDrapeau.Height - 2);
outilsGraphiques.Dispose();
}
/// <summary>
/// Trace une ligne entre les deux régions indiquées.
/// </summary>
/// <param name="pointilles">Indique si la ligne doit être en pointillés ou non.</param>
/// <param name="typeBout">Type de bout (flèche, carré) souhaité pour la ligne.</param>
/// <param name="pointDepart">Point où débute le trait.</param>
/// <param name="pointArrivee">Point où se termine le trait.</param>
/// <param name="belligerant">Identificateur du belligérant associé à l'ordre.</param>
/// <param name="carte">Image représentant la carte.</param>
/// <param name="outilsGraphiques">Outils graphiques utilisés pour effectuer le dessin.</param>
private static void TraceLigne(
Boolean pointilles,
LineCap typeBout,
Point pointDepart,
Point pointArrivee,
EBelligerant belligerant,
Image carte,
Graphics outilsGraphiques)
{
Color couleur = Convertisseurs.VersCouleur(belligerant);
Color couleurBis;
if (belligerant == EBelligerant.Mélinde)
{
couleurBis = Color.Black;
}
else if (belligerant == EBelligerant.Palavin)
{
couleurBis = Color.Red;
}
else
{
couleurBis = couleur;
}
Pen traceur = new Pen(couleur, 2.0F);
Pen traceurBis = new Pen(couleurBis, 3.0F);
traceur.EndCap = typeBout;
traceurBis.EndCap = typeBout;
if (pointilles == true)
{
traceur.DashStyle = DashStyle.Dash;
traceurBis.DashStyle = DashStyle.Dash;
}
outilsGraphiques.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
outilsGraphiques.DrawLine(traceurBis, pointDepart, pointArrivee);
outilsGraphiques.DrawLine(traceur, pointDepart, pointArrivee);
}
/// <summary>
/// Retourne l'ordre d'ajustement associé au contrôle.
/// </summary>
/// <returns>Ordre d'ajustement associé au contrôle.</returns>
public Ajuster RetourneAjustement()
{
EUnite unite;
EAjustement ajustement;
String nomRegion = this.region.Text;
EBelligerant belligerant = Convertisseurs.DepuisEBelligerantAbrege(this.Belligerant.Text);
if (this.comboBox.Visible == true)
{
String recrutement = this.comboBox.Text;
if (recrutement != "")
{
unite = Convertisseurs.VersEUnite(recrutement);
ajustement = EAjustement.Recrutement;
}
else
{
unite = EUnite.Aucune;
ajustement = EAjustement.Aucun;
}
}
else
{
unite = Convertisseurs.DepuisEUniteAbrege(this.Unite.Text);
if (this.Ordre.Text == "*")
{
ajustement = EAjustement.Congédiement;
}
else
{
ajustement = EAjustement.Aucun;
}
}
Ajuster ordre = new Ajuster(ajustement, unite, belligerant, nomRegion);
return(ordre);
}
/// <summary>
/// Affilie un centre à un belligérant.
/// </summary>
/// <param name="region">Région dont le centre est à affilier.</param>
/// <param name="occupation">Occupation du centre.</param>
/// <param name="carte">Image représentant la carte.</param>
/// <param name="outilsGraphiques">Outils graphiques utilisés pour effectuer le dessin.</param>
public static void AffilieCentre(Centre region, OccupationCentre occupation, Image carte, Graphics outilsGraphiques)
{
if (region.EstUnCentre == true)
{
/// Les centres mesurent 7x7 pixels.
Pen traceurContour = new Pen(Color.Black);
if (occupation.PossesseurCentre == EBelligerant.Palavin)
{
traceurContour = new Pen(Color.Red);
}
outilsGraphiques.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.None;
outilsGraphiques.DrawRectangle(traceurContour, region.CoordonneesCentre.X, region.CoordonneesCentre.Y, 7, 7);
Color couleur = Convertisseurs.VersCouleur(occupation.PossesseurCentre);
Brush traceur = new SolidBrush(couleur);
outilsGraphiques.FillRectangle(traceur, region.CoordonneesCentre.X + 1, region.CoordonneesCentre.Y + 1, 6, 6);
}
else
{
throw new Exception(String.Format("La région {0} ne contient pas de centre.", region.Nom));
}
}
/// <summary>
/// Initialise le dictionnaire des régions.
/// </summary>
/// <param name="fichierACharger">Chemin d'accès au fichier à charger contenant le dictionnaire des régions.</param>
private void InitialiseDictionnaireRegions(String fichierACharger)
{
this.DictionnaireRecrutement = new Dictionary <EBelligerant, List <String> >();
this.dictionnaireRegions = new Dictionary <string, GRegion>();
this.DictionnaireOccupation = new Dictionary <string, OccupationRegion>();
using (StreamReader lecteur = new StreamReader(fichierACharger))
{
foreach (String nomRegion in this.ListeNomsRegions)
{
String donnees = lecteur.ReadLine();
String[] donneesDetaillees = donnees.Split(';');
if (donneesDetaillees[0] == nomRegion)
{
String abreviation = donneesDetaillees[1];
Boolean centre = Boolean.Parse(donneesDetaillees[2]);
ETypeRegion typeRegion = (ETypeRegion)(Int32.Parse(donneesDetaillees[3]));
Coordonnees coordonneesUnite = Coordonnees.Convertit(donneesDetaillees[4]);
EBelligerant possesseurUnite = (EBelligerant)(Int32.Parse(donneesDetaillees[5]));
EUnite unite = (EUnite)(Int32.Parse(donneesDetaillees[6]));
if (centre == false)
{
GRegion nouvelleRegion = new GRegion(nomRegion, abreviation, typeRegion, coordonneesUnite);
this.dictionnaireRegions.Add(nomRegion, nouvelleRegion);
OccupationRegion occupation = new OccupationRegion(nomRegion, unite, possesseurUnite);
this.DictionnaireOccupation.Add(nomRegion, occupation);
}
else
{
Coordonnees coordonneesCentre = Coordonnees.Convertit(donneesDetaillees[7]);
EBelligerant possesseurCentre = (EBelligerant)(Int32.Parse(donneesDetaillees[8]));
EBelligerant recrutement = (EBelligerant)(Int32.Parse(donneesDetaillees[9]));
Centre nouveauCentre = new Centre(
nomRegion,
abreviation,
typeRegion,
coordonneesUnite,
coordonneesCentre,
recrutement);
this.dictionnaireRegions.Add(nomRegion, nouveauCentre);
OccupationCentre occupation = new OccupationCentre(nomRegion, unite, possesseurUnite, possesseurCentre);
this.DictionnaireOccupation.Add(nomRegion, occupation);
if (recrutement != EBelligerant.Aucun)
{
if (this.DictionnaireRecrutement.ContainsKey(recrutement))
{
this.DictionnaireRecrutement[recrutement].Add(nomRegion);
}
else
{
this.DictionnaireRecrutement.Add(recrutement, new List <String>()
{
nomRegion
});
}
}
}
}
else
{
throw new Exception("Le fichier de régions ne correspond pas à la matrice d'adjacence.");
}
}
String retraite = lecteur.ReadLine();
while (retraite != null)
{
String[] retraiteDetaillee = retraite.Split(';');
String attaquant = retraiteDetaillee[0];
EBelligerant possesseur = Convertisseurs.VersEBelligerant(retraiteDetaillee[1]);
String region = retraiteDetaillee[2];
EUnite typeUnite = Convertisseurs.VersEUnite(retraiteDetaillee[3]);
OrdreRegional nouvelleRetraite = new OrdreRegional(typeUnite, possesseur, region, attaquant);
this.ListeRetraites.Add(nouvelleRetraite);
retraite = lecteur.ReadLine();
}
}
}
/// <summary>
/// Finit le tour de jeu.
/// </summary>
private void finirTour(object sender, EventArgs e)
{
try
{
if (this.estInitialise == true)
{
this.SauvegardeDernierePartie();
this.raffraichit(sender, e);
this.exportCarte_ToolStripExport(sender, e);
this.ChargeCarteVierge();
Graphics outilsGraphiques = Graphics.FromImage(this.imageCarteInterne);
outilsGraphiques.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.None;
if (this.emplacementPhase.Text == "Ordres")
{
List <OrdreAbstrait> listeOrdres = this.LitOrdres();
this.conteneurDonnees.FinitTour(false, listeOrdres, this.imageCarteInterne, outilsGraphiques);
}
else if (this.emplacementPhase.Text == "Retraites")
{
List <Attaquer> ordresRetraites = this.LitRetraites();
this.conteneurDonnees.GereRetraites(ordresRetraites, this.imageCarteInterne, outilsGraphiques);
this.conteneurDonnees.ListeRetraites.Clear();
}
else if (this.emplacementPhase.Text == "Ajustements")
{
List <Ajuster> ordresAjustement = this.LitAjustements();
this.conteneurDonnees.GereAjustements(ordresAjustement);
}
else
{
throw new Exception("La définition / conversion des phases n'a pas été mise à jour.");
}
this.conteneurDonnees.InitialiseCarte(this.imageCarteInterne, outilsGraphiques);
outilsGraphiques.Dispose();
this.imageCarte.Invalidate();
this.estRafraichi = false;
this.exportCarte_ToolStripExport(sender, e);
if (this.emplacementPhase.Text == "Ordres" && this.conteneurDonnees.ListeRetraites.Count == 0)
{
this.conteneurDonnees.PeriodeCourante.Incremente();
}
this.conteneurDonnees.PeriodeCourante.Incremente();
this.emplacementDate.Text = this.conteneurDonnees.PeriodeCourante.ToString();
this.emplacementPhase.Text = Convertisseurs.VersPhaseJeuAbregee(this.conteneurDonnees.PhaseCourante);
if (this.emplacementPhase.Text == "Ajustements")
{
this.conteneurDonnees.GereAllegeancesCentres();
this.InitialiseCarte();
}
this.CreeChampsOrdres(this.emplacementPhase.Text);
}
}
catch (Exception exceptionRecuperee)
{
MessageBox.Show(exceptionRecuperee.Message);
}
}
