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