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