/// <summary>
/// Initialise une nouvelle instance de la classe Ajuster.
/// </summary>
/// <param name="recrutement">Type d'ajustement à effectuer.</param>
/// <param name="unite">Type de l'unité concernée par l'ordre.</param>
/// <param name="belligerant">Belligérant auquel appartient / va appartenir l'unité concernée.</param>
/// <param name="nomRegion">Nom de la région concernée.</param>
public Ajuster(EAjustement recrutement, EUnite unite, EBelligerant belligerant, String nomRegion)
{
this.Recrutement = recrutement;
this.Region = nomRegion;
this.Unite = unite;
this.Belligerant = belligerant;
}
/// <summary>
/// Change l'unité présente dans la région.
/// </summary>
/// <param name="nouvelleUnite">Nouvelle unité présente dans la région.</param>
/// <param name="nouveauPossesseur">Nom de la puissance possédant la nouvelle unité.</param>
public void ChangeUnite(EUnite nouvelleUnite, EBelligerant nouveauPossesseur)
{
this.typeUnite = nouvelleUnite;
this.possesseurUnite = nouveauPossesseur;
this.TypeFutureUnite = nouvelleUnite;
this.FuturPossesseurUnite = nouveauPossesseur;
}
/// <summary>
/// Initialise une nouvelle instance de la classe OrdreRegional (pour la sauvegarde des retraites uniquement).
/// </summary>
/// <param name="typeUnite">Type de l'unité présente dans la région.</param>
/// <param name="possesseur">Possesseur de l'unité présente dans la région.</param>
/// <param name="region">Nom de la région.</param>
/// <param name="attaquant">Nom de la région d'où provient l'attaque forçant à faire retraite.</param>
public OrdreRegional(EUnite typeUnite, EBelligerant possesseur, String region, String attaquant)
{
this.region = region;
this.Retraite = true;
this.Attaquant = attaquant;
this.TypeUnite = typeUnite;
this.Possesseur = possesseur;
}
/// <summary>
/// Initialise une nouvelle instance de la classe OccupationRegion.
/// </summary>
/// <param name="nomRegion">Nom de la région concernée.</param>
/// <param name="typeUnite">Type de l'unité présente dans la région.</param>
/// <param name="possesseurUnite">Possesseur de l'unité présente dans la région.</param>
public OccupationRegion(String nomRegion, EUnite typeUnite, EBelligerant possesseurUnite)
{
this.nomRegion = nomRegion;
this.typeUnite = typeUnite;
this.possesseurUnite = possesseurUnite;
this.TypeFutureUnite = EUnite.Aucune;
this.FuturPossesseurUnite = EBelligerant.Aucun;
}
/// <summary>
/// Initialise une nouvelle instance de la classe SoutenirOffensif.
/// </summary>
/// <param name="unite">Type de l'unité concernée par l'ordre.</param>
/// <param name="belligerant">Belligérant auquel appartient l'unité concernée.</param>
/// <param name="regionSoutenant"> Nom de la région où est donné l'ordre.</param>
/// <param name="regionSoutenue">Nom de la région attaquante soutenue à l'aide de l'ordre.</param>
/// <param name="regionAttaquee">Nom de la région contre laquelle l'ordre induit un soutien.</param>
public SoutenirOffensif(
EUnite unite,
EBelligerant belligerant,
String regionSoutenant,
String regionSoutenue,
String regionAttaquee)
: base(unite, belligerant, regionSoutenant)
{
this.regionSoutenue = regionSoutenue;
this.regionAttaquee = regionAttaquee;
this.TypeOrdre = EOrdre.SoutienOffensif;
}
/// <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>
/// Convertit l'élément de EUnite en une chaîne de caractères abrégée.
/// </summary>
/// <param name="identificateurUnite">Identificateur de l'unité en tant qu'élément de EUnite.</param>
/// <returns>Identificateur de l'unité sous forme d'une chaîne de caractères abrégée.</returns>
public static String VersEUniteAbrege(EUnite identificateurUnite)
{
String identificateurAbrege;
switch (identificateurUnite)
{
case EUnite.Flotte:
identificateurAbrege = "F";
break;
case EUnite.Aucune:
throw new Exception("Le convertisseur ne devrait pas être appelé dans un cas pareil.");
default:
identificateurAbrege = "A";
break;
}
return(identificateurAbrege);
}
/// <summary>
/// Convertit la chaîne de caractères en un élément de EUnite.
/// </summary>
/// <param name="identificateurUnite">Identificateur de l'unité sous forme d'une chaîne de caractères.</param>
/// <returns>Identificateur de l'unité en tant qu'élément de EUnite.</returns>
public static EUnite VersEUnite(String identificateurUnite)
{
EUnite unite = (EUnite)(Enum.Parse(typeof(EUnite), identificateurUnite));
return(unite);
}
/// <summary>
/// Initialise une nouvelle instance de la classe Attaquer.
/// </summary>
/// <param name="unite">Type de l'unité concernée par l'ordre.</param>
/// <param name="belligerant">Belligérant auquel appartient l'unité concernée.</param>
/// <param name="regionAttaquante">Nom de la région où est donné l'ordre.</param>
/// <param name="regionAttaquee">Nom de la région attaquée.</param>
public Attaquer(EUnite unite, EBelligerant belligerant, String regionAttaquante, String regionAttaquee)
: base(unite, belligerant, regionAttaquante)
{
this.nomRegionAttaquee = regionAttaquee;
this.TypeOrdre = EOrdre.Attaque;
}
/// <summary>
/// Congédie l'unité présente dans la région.
/// </summary>
public void Congedie()
{
this.typeUnite = EUnite.Aucune;
this.possesseurUnite = EBelligerant.Aucun;
}
/// <summary>
/// Recrute dans la région.
/// </summary>
/// <param name="unite">Type d'unité à recruter.</param>
/// <param name="belligerant">Belligérant pour lequel recruter.</param>
public void Recrute(EUnite unite, EBelligerant belligerant)
{
this.typeUnite = unite;
this.possesseurUnite = belligerant;
}
/// <summary>
/// Détruit l'unité présente dans une région, ou abandonne celle-ci.
/// </summary>
public void DetruitOuAbandonne()
{
this.typeUnite = this.TypeFutureUnite;
this.possesseurUnite = this.FuturPossesseurUnite;
}
/// <summary>
/// Initialise une nouvelle instance de la classe Tenir.
/// </summary>
/// <param name="unite">Type de l'unité concernée par l'ordre.</param>
/// <param name="belligerant">Belligérant auquel appartient l'unité concernée.</param>
/// <param name="nomRegion">Nom de la région où est donné l'ordre.</param>
public Tenir(EUnite unite, EBelligerant belligerant, String nomRegion) : base(unite, belligerant, nomRegion)
{
this.TypeOrdre = EOrdre.Tenir;
}
/// <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>
/// Initialise une nouvelle instance de la classe OrdreAbstrait.
/// </summary>
/// <param name="unite">Type de l'unité concernée par l'ordre.</param>
/// <param name="belligerant">Belligérant auquel appartient l'unité concernée.</param>
/// <param name="nomRegion">Nom de la région où est donné l'ordre.</param>
public OrdreAbstrait(EUnite unite, EBelligerant belligerant, String nomRegion)
{
this.unite = unite;
this.belligerant = belligerant;
this.nomRegion = nomRegion;
}
