Example #1
0
 /// <summary>
 /// Trace une flèche correspondant à un soutien défensif coupé.
 /// </summary>
 /// <param name="regionSoutenant">La région d'où est initié le soutien.</param>
 /// <param name="regionSoutenue">La région à laquelle profite le soutien.</param>
 /// <param name="belligerant">Identificateur du belligérant qui soutient.</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 TraceSoutienDefensifCoupe(
     GRegion regionSoutenant,
     GRegion regionSoutenue,
     EBelligerant belligerant,
     Image carte,
     Graphics outilsGraphiques)
 {
     TraceLigne(true, LineCap.SquareAnchor, regionSoutenant, regionSoutenue, belligerant, carte, outilsGraphiques);
 }
Example #2
0
 /// <summary>
 /// Trace une flèche correspondant à une attaque ratée.
 /// </summary>
 /// <param name="regionAttaquante">La région d'où provient l'attaque.</param>
 /// <param name="regionAttaquee">La région où aboutit l'attaque.</param>
 /// <param name="belligerant">Identificateur du belligérant à l'origine de l'attaque.</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 TraceAttaqueRatee(
     GRegion regionAttaquante,
     GRegion regionAttaquee,
     EBelligerant belligerant,
     Image carte,
     Graphics outilsGraphiques)
 {
     TraceLigne(true, LineCap.ArrowAnchor, regionAttaquante, regionAttaquee, belligerant, carte, outilsGraphiques);
 }
Example #3
0
        /// <summary>
        /// Trace une flèche correspondant à un transport interrompu.
        /// </summary>
        /// <param name="regionTransportant">La région où est effectué le transport.</param>
        /// <param name="regionTransportee">La région dont l'unité est transportée.</param>
        /// <param name="regionArrivee">La région où arrive l'unité transportée.</param>
        /// <param name="belligerant">Identificateur du belligérant qui effectue le transport.</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 TraceTransportInterrompu(
            GRegion regionTransportant,
            GRegion regionTransportee,
            GRegion regionArrivee,
            EBelligerant belligerant,
            Image carte,
            Graphics outilsGraphiques)
        {
            Point pointDepart  = PlaceExtremiteFleches(regionTransportant);
            Point pointArrivee = PlaceExtremiteFleches(regionTransportee, regionArrivee);

            TraceLigne(true, LineCap.RoundAnchor, pointDepart, pointArrivee, belligerant, carte, outilsGraphiques);
        }
Example #4
0
        /// <summary>
        /// Trace une flèche correspondant à un soutien offensif coupé.
        /// </summary>
        /// <param name="regionSoutenant">La région d'où est initié le soutien.</param>
        /// <param name="regionSoutenue">La région à laquelle profite le soutien.</param>
        /// <param name="regionAttaquee">La région à laquelle nuit le soutien.</param>
        /// <param name="belligerant">Identificateur du belligérant qui soutient.</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 TraceSoutienOffensifCoupe(
            GRegion regionSoutenant,
            GRegion regionSoutenue,
            GRegion regionAttaquee,
            EBelligerant belligerant,
            Image carte,
            Graphics outilsGraphiques)
        {
            Point pointDepart  = PlaceExtremiteFleches(regionSoutenant);
            Point pointArrivee = PlaceExtremiteFleches(regionSoutenue, regionAttaquee);

            TraceLigne(true, LineCap.SquareAnchor, pointDepart, pointArrivee, belligerant, carte, outilsGraphiques);
        }
Example #5
0
        /// <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="regionDebut">Région où débute le trait.</param>
        /// <param name="regionFin">Région 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,
            GRegion regionDebut,
            GRegion regionFin,
            EBelligerant belligerant,
            Image carte,
            Graphics outilsGraphiques)
        {
            Point pointDepart  = PlaceExtremiteFleches(regionDebut);
            Point pointArrivee = PlaceExtremiteFleches(regionFin);

            TraceLigne(pointilles, typeBout, pointDepart, pointArrivee, belligerant, carte, outilsGraphiques);
        }
Example #6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="premiereRegion"></param>
        /// <param name="secondeRegion"></param>
        /// <returns></returns>
        private static Point PlaceExtremiteFleches(GRegion premiereRegion, GRegion secondeRegion)
        {
            /// L'image pour les flottes mesure 23x20 pixels, celle pour les armées 20x20 pixels.
            Int32 decalageHorizontal = 10;
            Int32 decalageVertical   = 10;

            Point debut = new Point(
                premiereRegion.CoordonneesUnite.X + decalageHorizontal,
                premiereRegion.CoordonneesUnite.Y + decalageVertical);
            Point fin = new Point(
                secondeRegion.CoordonneesUnite.X + decalageHorizontal,
                secondeRegion.CoordonneesUnite.Y + decalageVertical);

            Point moyenne = new Point((debut.X + fin.X) / 2, (debut.Y + fin.Y) / 2);

            return(moyenne);
        }
Example #7
0
        /// <summary>
        /// Initialise l'image de la carte.
        /// </summary>
        /// <param name="carte">Image actuelle de la carte.</param>
        public void InitialiseCarte(Image carte, Graphics outilsGraphiques)
        {
            foreach (String nomRegion in this.ListeNomsRegions)
            {
                /// On fait deux fois les tests (y a-t-il un centre ? y a-t-il une unité ?), puisqu'ils sont aussi faits
                /// dans les fonctions de Pictogrammes. Mais cela permet de mieux saisir ce que l'on fait...
                GRegion          regionActuelle = this.DictionnaireRegions[nomRegion];
                OccupationRegion occupation     = this.DictionnaireOccupation[nomRegion];

                if (regionActuelle.EstUnCentre == true)
                {
                    Pictogrammes.AffilieCentre(regionActuelle as Centre, occupation as OccupationCentre, carte, outilsGraphiques);
                }

                if (occupation.TypeUnite != EUnite.Aucune)
                {
                    Pictogrammes.PlaceUnite(regionActuelle, occupation, carte, outilsGraphiques);
                }
            }
        }
Example #8
0
        /// <summary>
        /// Place une unité dans une région.
        /// </summary>
        /// <param name="region">Région dans laquelle placer une unité.</param>
        /// <param name="occupation">Occupation de la région.</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 PlaceUnite(GRegion region, OccupationRegion occupation, Image carte, Graphics outilsGraphiques)
        {
            if (occupation.TypeUnite != EUnite.Aucune)
            {
                String dossierActuel = Directory.GetCurrentDirectory();
                String imageACharger;
                if (occupation.TypeUnite == EUnite.Flotte)
                {
                    imageACharger = dossierActuel.Replace(@"diplo.IHM\bin\Debug", @"Images\Flotte");
                }
                else
                {
                    imageACharger = dossierActuel.Replace(@"diplo.IHM\bin\Debug", @"Images\Armée");
                }

                String identificateurBelligerant = ((Int32)(occupation.PossesseurUnite)).ToString();
                imageACharger = imageACharger + "0" + identificateurBelligerant + ".png";

                Image imageUnite = new Bitmap(imageACharger);
                outilsGraphiques.DrawImage(imageUnite, region.CoordonneesUnite.X, region.CoordonneesUnite.Y);
            }
        }
Example #9
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();
                }
            }
        }
Example #10
0
        /// <summary>
        /// Finit le tour en cours.
        /// </summary>
        /// <param name="retraites">Indique s'il s'agit d'un tour de retraites ou non.</param>
        /// <param name="ordres">Liste des ordres 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 FinitTour(Boolean retraites, List <OrdreAbstrait> ordres, Image carte, Graphics outilsGraphiques)
        {
            ListeOrdres listeOrdres = new ListeOrdres(
                ordres,
                this.DictionnaireAdjacence,
                this.dictionnaireRegions,
                this.DictionnaireOccupation);
            List <OrdreAbstrait> ordresValides = listeOrdres.OrdresValides;

            this.dictionnaireOrdres.EnregistreOrdres(ordresValides, this.DictionnaireOccupation);
            this.dictionnaireOrdres.AppliqueOrdres(ordresValides);

            foreach (OrdreRegional ordreRegional in this.dictionnaireOrdres.Dictionnaire.Values)
            {
                if (ordreRegional.TypeOrdre != EOrdre.Tenir)
                {
                    GRegion regionConcerne = this.DictionnaireRegions[ordreRegional.Region];
                    GRegion regionCiblee   = this.DictionnaireRegions[ordreRegional.RegionCiblee];
                    switch (ordreRegional.TypeOrdre)
                    {
                    case EOrdre.AttaqueReussie:
                        Pictogrammes.TraceAttaque(regionConcerne, regionCiblee, ordreRegional.Possesseur, carte, outilsGraphiques);
                        this.IntegreAttaqueReussie(retraites, ordreRegional);
                        break;

                    case EOrdre.AttaqueEchouee:
                        Pictogrammes.TraceAttaqueRatee(regionConcerne, regionCiblee, ordreRegional.Possesseur, carte, outilsGraphiques);
                        break;

                    case EOrdre.Convoi:
                        GRegion regionArrivee = this.DictionnaireRegions[this.dictionnaireOrdres.Dictionnaire[regionCiblee.Nom].RegionCiblee];
                        Pictogrammes.TraceTransport(regionConcerne, regionCiblee, regionArrivee, ordreRegional.Possesseur, carte, outilsGraphiques);
                        break;

                    case EOrdre.ConvoiCoupe:
                        GRegion regionArriveeBis = this.DictionnaireRegions[this.dictionnaireOrdres.Dictionnaire[regionCiblee.Nom].RegionCiblee];
                        Pictogrammes.TraceTransportInterrompu(regionConcerne, regionCiblee, regionArriveeBis, ordreRegional.Possesseur, carte, outilsGraphiques);
                        break;

                    case EOrdre.SoutienDefensif:
                        Pictogrammes.TraceSoutienDefensif(regionConcerne, regionCiblee, ordreRegional.Possesseur, carte, outilsGraphiques);
                        break;

                    case EOrdre.SoutienDefensifCoupe:
                        Pictogrammes.TraceSoutienDefensifCoupe(regionConcerne, regionCiblee, ordreRegional.Possesseur, carte, outilsGraphiques);
                        break;

                    case EOrdre.SoutienOffensif:
                        GRegion regionAttaquee = this.DictionnaireRegions[this.dictionnaireOrdres.Dictionnaire[regionCiblee.Nom].RegionCiblee];
                        Pictogrammes.TraceSoutienOffensif(regionConcerne, regionCiblee, regionAttaquee, ordreRegional.Possesseur, carte, outilsGraphiques);
                        break;

                    case EOrdre.SoutienOffensifCoupe:
                        GRegion regionAttaqueeBis = this.DictionnaireRegions[this.dictionnaireOrdres.Dictionnaire[regionCiblee.Nom].RegionCiblee];
                        Pictogrammes.TraceSoutienOffensifCoupe(regionConcerne, regionCiblee, regionAttaqueeBis, ordreRegional.Possesseur, carte, outilsGraphiques);
                        break;

                    default:
                        break;
                    }
                }
            }

            this.NettoieDictionnaireOccupation();
            this.ListeRetraites = this.dictionnaireOrdres.Dictionnaire.Values.Where(item => item.Retraite == true && item.TypeUnite != EUnite.Aucune).ToList();
        }
Example #11
0
        /// <summary>
        /// Sauvegarde les données de la partie courante.
        /// </summary>
        /// <param name="cheminDictionnaireRegions">Fichier dans lequel sauvegarder le dictionnaire des régions.</param>
        public void Sauvegarde(String cheminDictionnaireRegions)
        {
            using (StreamWriter redacteur = new StreamWriter(cheminDictionnaireRegions))
            {
                foreach (String nomRegion in this.ListeNomsRegions)
                {
                    GRegion regionASauvegarder = this.DictionnaireRegions[nomRegion];
                    String  abreviation        = regionASauvegarder.Abreviation;
                    String  centre             = regionASauvegarder.EstUnCentre.ToString();
                    String  typeRegion         = ((Int32)(regionASauvegarder.TypeRegion)).ToString();
                    String  coordonneesUnites  = regionASauvegarder.CoordonneesUnite.Convertit();

                    OccupationRegion occupationASauvegarder = this.DictionnaireOccupation[nomRegion];
                    String           possesseurUnite        = ((Int32)(occupationASauvegarder.PossesseurUnite)).ToString();
                    String           unite = ((Int32)(occupationASauvegarder.TypeUnite)).ToString();

                    String donneesCompletes;
                    if (regionASauvegarder.EstUnCentre == false)
                    {
                        donneesCompletes = String.Format(
                            "{0};{1};{2};{3};{4};{5};{6}",
                            nomRegion,
                            abreviation,
                            centre,
                            typeRegion,
                            coordonneesUnites,
                            possesseurUnite,
                            unite);
                    }
                    else
                    {
                        Centre centreASAuvegarder = regionASauvegarder as Centre;
                        String coordonneesCentre  = centreASAuvegarder.CoordonneesCentre.Convertit();

                        OccupationCentre occupationCentre = occupationASauvegarder as OccupationCentre;
                        String           possesseurCentre = ((Int32)(occupationCentre.PossesseurCentre)).ToString();

                        String recrutement = ((Int32)(centreASAuvegarder.Recrutement)).ToString();

                        donneesCompletes = String.Format(
                            "{0};{1};{2};{3};{4};{5};{6};{7};{8};{9}",
                            nomRegion,
                            abreviation,
                            centre,
                            typeRegion,
                            coordonneesUnites,
                            possesseurUnite,
                            unite,
                            coordonneesCentre,
                            possesseurCentre,
                            recrutement);
                    }

                    redacteur.WriteLine(donneesCompletes);
                }

                foreach (var retraite in this.ListeRetraites)
                {
                    redacteur.WriteLine(
                        "{0};{1};{2};{3}",
                        retraite.Attaquant,
                        retraite.Possesseur,
                        retraite.Region,
                        retraite.TypeUnite);
                }
            }
        }
Example #12
0
 /// <summary>
 /// Fournit les coordonnées de l'extrémité d'une flèche dans la région donnée.
 /// </summary>
 /// <param name="region">Région dans laquelle placer l'extrémité d'une flèche.</param>
 /// <returns>Coordonnées de l'extrémité d'une flèche dans la région donnée.</returns>
 private static Point PlaceExtremiteFleches(GRegion region)
 {
     return(PlaceExtremiteFleches(region, region));
 }