Esempio n. 1
0
 /// <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;
 }
Esempio n. 2
0
        /// <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;
        }
Esempio n. 3
0
 /// <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;
 }
Esempio n. 4
0
        /// <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;
        }
Esempio n. 5
0
 /// <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;
 }
Esempio n. 6
0
        /// <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);
            }
        }
Esempio n. 7
0
 /// <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.");
     }
 }
Esempio n. 8
0
        /// <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);
        }
Esempio n. 9
0

        
Esempio n. 10
0
        /// <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);
        }
Esempio n. 11
0
 /// <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;
 }
Esempio n. 12
0
 /// <summary>
 /// Congédie l'unité présente dans la région.
 /// </summary>
 public void Congedie()
 {
     this.typeUnite       = EUnite.Aucune;
     this.possesseurUnite = EBelligerant.Aucun;
 }
Esempio n. 13
0
 /// <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;
 }
Esempio n. 14
0
 /// <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;
 }
Esempio n. 15
0
 /// <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;
 }
Esempio n. 16
0
        /// <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();
                }
            }
        }
Esempio n. 17
0
 /// <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;
 }