private void AttachObservers()
{
foreach (var o in Fenetre.Observers())
{
Attach(o);
}
}
/// <summary>
/// public override void sourisGaucheRelachee(MouseEventArgs e)
///
/// Cette fonction termine la sélection des objets
/// </summary>
/// <param name="e">
/// L'évènement relié au relâchement du bouton gauche de la souris
/// </param>
public override void SourisGaucheRelachee(MouseEventArgs e)
{
var ajout = ((Control.ModifierKeys & Keys.Control) != 0);
var nbSel = 0;
if (!EstClic)
{
FonctionsNatives.terminerRectangle(PositionXDebut, PositionYDebut, e.X, e.Y);
nbSel = FonctionsNatives.selectionner((PositionXDebut + e.X) / 2, (PositionYDebut + e.Y) / 2, Math.Max(Math.Abs(PositionXDebut - e.X), 2), Math.Max(Math.Abs(PositionYDebut - e.Y), 2), ajout);
EstClic = true;
}
else
{
nbSel = FonctionsNatives.selectionner(e.X, e.Y, 3, 3, ajout);
}
Fenetre.AfficherPanelEditionObjet(nbSel == 1);
if (nbSel == 0)
{
Fenetre.DesactiverBoutons(false);
}
else
{
Fenetre.DesactiverBoutons(true);
}
if (nbSel == 1)
{
Fenetre.MettreAJourParametres();
}
Fenetre.AssignerBoutonSupprimer(nbSel != 0);
Fenetre.MettreAJour();
}
static void JeuPuissance4() //pas de return dans la fonction même
{
// on initialise la matrice qui nous servira de support pour le jeu
for (int i = 0; i < NBLIGINT; i++)
{
for (int j = 0; j < NBCOLINT; j++)
{
arraySupportDeJeuInt[i, j] = CASEVIDE;
}
}
Fenetre gui = new Fenetre(arraySupportDeJeuInt);
int noJoueurInt = 2; // Au premier tour, c'est le joueur 1 qui joue
while (lecteurGeneral() == false && egaliteBool() == false) // Tant que le lecteur n'a pas trouvé de combinaison, on continue le jeu
{
AfficherLeJeu(); // Affiche le tableau avec les différents changements
// ici initialisé à 0
gui.rafraichirGrille();
//Début du jeu, on commence le premier tour
//Etape 1 : Changer le tour des joueurs
noJoueurInt = changerDeJoueurInt(noJoueurInt);
Console.WriteLine("C'est au tour du joueur " + noJoueurInt);
gui.changerMessage("C'est au tour du joueur " + noJoueurInt);
//Etape 2 : Je demande la colonne
//Etape 3 : J'ai ma colonne : je place le jeton
int colonneSaisieInt;
do
{
colonneSaisieInt = choisirUneColonne(); //on sort du while si c'est true
}while (!placerLeJetonBool(noJoueurInt, colonneSaisieInt));
//Etape 4 : Mise en place d'un lecteur pour voir si la partie est terminée
if (scanColBool() == true || scanDiagGDHBool() == true || scanLigBool() == true || scanDiagGDBBool() == true)
{
AfficherLeJeu();
gui.rafraichirGrille();
Console.WriteLine(" Le joueur " + noJoueurInt + " a gagné ! Félicitation !");
gui.changerMessage("Le joueur " + noJoueurInt + " a gagné ! Félicitation !");
//Fin du programme
}
else if (egaliteBool() == true)
{
AfficherLeJeu();
gui.rafraichirGrille();
Console.WriteLine("Le jeu est terminé, il y a égalité !");
gui.changerMessage("Le jeu est terminé, il y a égalité !");
//Fin du programme
}
}
}
[System.STAThreadAttribute()] //Nous avons réussie à installer l'interface grafique
static void Main(string[] args)
{
int L = 0;
int Réponse = 0;
while (L < 3)
{
Console.WriteLine("===================="); Console.WriteLine("|Nombre de Lignes ?|"); Console.WriteLine("====================");
L = Convert.ToInt32(Console.ReadLine()); Console.Clear();
}
int C = 0;
{
Console.WriteLine("======================"); Console.WriteLine("|Nombre de Colonnes ?|"); Console.WriteLine("======================");
C = Convert.ToInt32(Console.ReadLine()); Console.Clear();
}
//Taux de remplissage
double T = 0;
while (T > 0.9 || T < 0.1)
{
Console.WriteLine("========================================================================");
Console.WriteLine("|Donnez le taux de remplissage des cellules vivantes (entre 0,1 et 0,9)|");
Console.WriteLine("========================================================================");
T = Convert.ToDouble(Console.ReadLine()); Console.Clear();
}
//Avec ou sans visualisation intermédiaire
int Visualisation = -1;
while (Visualisation != 1 && Visualisation != 2 && Visualisation != 3 && Visualisation != 4)
{
Console.WriteLine(" ............................................................................................"); Console.WriteLine(" ----------------------------------------------------------------------------------------------");
Console.WriteLine("| Voulez-vous : |"); Console.WriteLine("| 1- Le jeu de la Vie Classique sans la visualisation intermédiaire des états futurs |");
Console.WriteLine("| 2- Le jeu de la Vie Classique avec la visualisation intermédiaire des états futurs |"); Console.WriteLine("| 3- Le jeu de la Vie Variante (deux populations) sans la visualisation intermédiaire [NEW] |");
Console.WriteLine("| 4- Le jeu de la Vie Variante (deux populations) avec la visualisation intermédiaire [NEW] |");
Console.WriteLine(" ----------------------------------------------------------------------------------------------"); Console.WriteLine(" ............................................................................................");
Visualisation = Convert.ToInt32(Console.ReadLine()); Console.Clear();
}
while (Réponse == 0)
{
Console.WriteLine("======================="); Console.WriteLine("|Taille des cellules ?|"); Console.WriteLine("=======================");
Réponse = Convert.ToInt32(Console.ReadLine());
Console.Clear();
}
int[,] Grille = new int[L, C]; //Création de la grille de jeu
Initialisation(Grille, T, Visualisation); //Initialisation de départ de la grille de jeu
Fenetre gui = new Fenetre(Grille, Réponse, 0, 0);
//AfficherGrille(Grille); //Afficher une première fois la grille (Enlever les // pour remettre sur la console, mais vu qu'on utilise le GUI, nous n'en avons pas besoin)
// L'affiche de la grille va se faire la règle suivante : || 0 = cellule morte . || 1 = cellule en vie # || 2 = cellule qui nait - ||3 = cellule qui meurt * ||
gui.Rafraichir(); // mise à jour de l'interface graphique
LeJeuxDeLaVie(Grille, Visualisation, gui);
Console.ReadKey();
}
/// <summary>
/// public override void sourisDeplacee(object o, MouseEventArgs e)
///
/// Cette fonction fait suivre le deuxième bout du mur à la souris
/// </summary>
/// <param name="o"></param>
/// <param name="e">
/// L'évènement relié au déplacement de la souris
/// </param>
public override void SourisDeplacee(object o, MouseEventArgs e)
{
Fenetre.CheckSouris(e.X, e.Y);
if (_creerVraiMur)
{
FonctionsNatives.murFantome(e.X, e.Y);
Fenetre.MettreAJour();
}
base.SourisDeplacee(o, e);
}
/// <summary>
/// public override void sourisGaucheEnfoncee(MouseEventArgs e)
///
/// Cette fonction termine la duplication de l'objet
/// </summary>
/// <param name="e">
/// L'évènement relié à l'enfoncement du bouton gauche de la souris
/// </param>
public override void SourisGaucheEnfoncee(MouseEventArgs e)
{
if (_duplicationEnCours)
{
FonctionsNatives.finirDuplication();
_duplicationEnCours = false;
Fenetre.MettreAJour();
}
SourisDroiteEnfoncee(e);
}
static void Main(string[] args)
{
/* Le plateau était à l'origine une matrice de chaînes de caractères pour pouvoir "personnaliser" les jetons
* mais il a été modifié en matrice d'entiers afin de pouvoir utiliser l'interface graphique d'où la présence
* des constantes. */
const int ID_VIDE = 0;
const int ID_JOUEUR_1 = 1;
const int ID_JOUEUR_2 = 2;
int nbTour = 0;
bool finDuJeu = false; // finDuJeu correspond au cas où l'un des joueurs a gagné.
int[,] plateau = InitialisationPlateau(6, 7, ID_VIDE);
Fenetre gui = new Fenetre(plateau);
AfficherPlateau(plateau);
while (finDuJeu == false && nbTour < plateau.GetLength(0) * plateau.GetLength(1))
{
if ((nbTour % 2) + 1 == 1)
{
Console.WriteLine("C'est au tour du joueur 1.");
gui.changerMessage("C'est au tour du joueur 1.");
PhaseJoueur(plateau, ID_VIDE, ID_JOUEUR_1);
finDuJeu = CombinaisonGagnanteTrouvee(plateau, ID_JOUEUR_1);
if (finDuJeu == true)
{
Console.WriteLine("Le joueur 1 a gagné.");
gui.changerMessage("Le joueur 1 a gagné.");
}
}
else
{
Console.WriteLine("C'est au tour du joueur 2.");
gui.changerMessage("C'est au tour du joueur 2.");
PhaseJoueur(plateau, ID_VIDE, ID_JOUEUR_2);
finDuJeu = CombinaisonGagnanteTrouvee(plateau, ID_JOUEUR_2);
if (finDuJeu == true)
{
Console.WriteLine("Le joueur 2 a gagné.");
gui.changerMessage("Le joueur 2 a gagné.");
}
}
AfficherPlateau(plateau);
gui.rafraichirGrille();
nbTour++;
}
if (finDuJeu == false) // Le cas où toutes les cases ont été remplis sans qu'il n'y ait de gagnant.
{
Console.WriteLine("Match nul !");
}
Console.WriteLine("\nFin du programme.");
gui.changerMessage("Fin du programme.");
Console.ReadKey();
}
/// <summary>
/// public override void sourisDeplacee(object o, MouseEventArgs e)
///
/// Cette fonction effectue la rotation de l'objet selon le déplacement de l'objet en y
/// </summary>
/// <param name="o"></param>
/// <param name="e">
/// L'évènement reliée au déplacement de la souris
/// </param>
public override void SourisDeplacee(object o, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
FonctionsNatives.rotaterSelection(PositionYDernier, e.Y);
PositionYDernier = e.Y;
Fenetre.MettreAJour();
}
base.SourisDeplacee(o, e);
}
private void buttonFenetre_Click(object sender, EventArgs e)
{
TabControl tab = new TabControl();
tab.Height = tabControl.Height;
tab.Width = tabControl.Width;
_pagesInWindow.Add(tabControl.SelectedTab);
tab.TabPages.Add(tabControl.SelectedTab);
Fenetre fen = new Fenetre(tab);
fen.Show();
fen.FormClosing += fen_FormClosing;
}
/// <summary>
/// public override void toucheEnfoncee(KeyEventArgs e)
///
/// Cette fonction vérifie si la touche Échappe est enfoncée et agit en conséquence
/// </summary>
/// <param name="e">
/// L'évènement relié à l'enfoncement d'une touche du clavier
/// </param>
public override void ToucheEnfoncee(KeyEventArgs e)
{
base.ToucheEnfoncee(e);
if ((_nomObjet.ToString() == "mur" || _nomObjet.ToString() == "portail") && _objetCree && (_creerPortail || _creerVraiMur))
{
switch (e.KeyCode)
{
case (Keys.Escape):
FonctionsNatives.annulerCreation();
_creerVraiMur = false;
_objetCree = false;
_creerPortail = false;
break;
}
}
Fenetre.MettreAJour();
}
/// <summary>
/// public override void sourisGaucheRelachee(MouseEventArgs e)
///
/// Cette fonction termine le rectangle élastique de zoom
/// </summary>
/// <param name="e">
/// L'évènement relié au relâchement du bouton gauche de la souris
/// </param>
public override void SourisGaucheRelachee(MouseEventArgs e)
{
if (!EstClic)
{
FonctionsNatives.terminerRectangle(PositionXDebut, PositionYDebut, e.X, e.Y);
EstClic = true;
if ((Control.ModifierKeys & Keys.Alt) != 0)
{
FonctionsNatives.zoomOutRect(PositionXDebut, PositionYDebut, e.X, e.Y);
}
else
{
FonctionsNatives.zoomInRect(PositionXDebut, PositionYDebut, e.X, e.Y);
}
Fenetre.MettreAJour();
}
}
static void Main(string[] args)
{
int nbCoupsVictoire = NombreCoupsPourGagner();
Console.Clear();
int[,] grille = CreationGrille(nbCoupsVictoire);
Console.Clear();
Fenetre gui = new Fenetre(grille);
gui.changerMessage("ALI M'HIRI 3A ESILV 2015-2016");
gui.rafraichirGrille();
int noJoueur = 2;
int colonne = 0;
bool victoire = false;
bool egalite = false;
while (!Victoire(grille, noJoueur, nbCoupsVictoire) && !Egalite(grille))
{
noJoueur = (noJoueur % 2) + 1;
Console.WriteLine("C'est au tour du joueur " + noJoueur);
colonne = SaisirUnNumColonneValide(grille);
ModifierGrille(grille, colonne - 1, noJoueur);
victoire = Victoire(grille, noJoueur, nbCoupsVictoire);
egalite = Egalite(grille);
gui.rafraichirGrille();
Console.WriteLine();
}
if (victoire)
{
Console.WriteLine("Le joueur " + noJoueur + " a gagné!");
}
else if (egalite)
{
Console.WriteLine("Egalité!");
}
Console.ReadKey();
} //Main()
void fen_FormClosing(object sender, FormClosingEventArgs e)
{
Fenetre fen = (Fenetre)sender;
TabControl tab = (TabControl)fen.Control;
TabPage page = tab.TabPages[0];
_pagesInWindow.Remove(page);
TabPage tabPrec = tabPrecedent[page];
bool trouve = false;
if (tabPrec == null)
{
tabControl.TabPages.Insert(0, page);
}
else
{
while (!trouve && tabPrec != null)
{
for (int i = 0; i < tabControl.TabPages.Count; i++)
{
if (tabControl.TabPages[i] == tabPrec)
{
trouve = true;
tabControl.TabPages.Insert(i + 1, page);
break;
}
}
if (!trouve)
{
tabPrec = tabPrecedent[tabPrec];
}
if (tabPrec == null)
{
tabControl.TabPages.Insert(0, page);
}
}
}
}
/// <summary>
/// public override void sourisDeplacee(object o, MouseEventArgs e)
///
/// Cette fonction déplace l'étampe de duplication
/// </summary>
/// <param name="o"></param>
/// <param name="e">
/// L'évènement reliée au déplacement de la souris
/// </param>
public override void SourisDeplacee(object o, MouseEventArgs e)
{
if (!_duplicationEnCours)
{
PositionXDebut = e.X;
PositionYDebut = e.Y;
PositionXDernier = e.X;
PositionYDernier = e.Y;
_duplicationEnCours = FonctionsNatives.initialiserDuplication(e.X, e.Y);
Fenetre.MettreAJour();
}
else
{
FonctionsNatives.deplacerSelection(e.X, PositionXDernier, e.Y, PositionYDernier, true);
PositionYDernier = e.Y;
PositionXDernier = e.X;
Fenetre.MettreAJour();
}
base.SourisDeplacee(o, e);
}
/// <summary>
/// public override void sourisGaucheRelachee(MouseEventArgs e)
///
/// Cette fonction crée l'objet à l'endroit où le bouton gauche de la
/// souris a été relâché.
/// </summary>
/// <param name="e">
/// L'évènement relié au relâchement du bouton gauche de la souris.
/// </param>
public override void SourisGaucheRelachee(MouseEventArgs e)
{
PositionXDernier = e.X;
PositionYDernier = e.Y;
if (!((Math.Abs(PositionXDebut - PositionXDernier) > 3) || (Math.Abs(PositionYDernier - PositionYDebut) > 3)))
{
if (_nomObjet.ToString() == "mur" && _creerVraiMur)
{
_creerVraiMur = false;
FonctionsNatives.finirCreationMur();
}
else if (_nomObjet.ToString() == "mur" && !_creerVraiMur)
{
_objetCree = FonctionsNatives.creerObjet(_nomObjet, _nomObjet.Length, PositionXDebut, PositionYDebut);
if (_nomObjet.ToString() == "mur" && _objetCree)
{
_creerVraiMur = true;
}
}
else if (_nomObjet.ToString() == "portail" && _creerPortail)
{
FonctionsNatives.creerObjet(_nomObjet, _nomObjet.Length, PositionXDebut, PositionYDebut);
_creerPortail = false;
}
else
{
_objetCree = FonctionsNatives.creerObjet(_nomObjet, _nomObjet.Length, PositionXDebut, PositionYDebut);
if (_nomObjet.ToString() == "portail" && _objetCree)
{
_creerPortail = true;
}
}
Fenetre.MettreAJour();
}
//System.Console.WriteLine(e.Location);
}
static void Main()
{
// initialiser la couche de persistance
ISessionFactory sessionFactory = ORM <Adherent> .CreateSessionFactory();
IDataAccess dataAccess = new DataAccess(sessionFactory);
// initialiser la couche applicative
ServiceExemplaires serviceExemplaires = new ServiceExemplaires(dataAccess);
ServiceAdherents serviceAdherents = new ServiceAdherents(dataAccess);
ServiceOuvrages serviceOuvrages = new ServiceOuvrages(dataAccess);
ServicePrets servicePrets = new ServicePrets(dataAccess);
// initializer la couche de presentation
Fenetre vue = new Fenetre(serviceAdherents, serviceOuvrages, servicePrets, serviceExemplaires);
// demarrer le logiciel
Application.EnableVisualStyles();
Application.Run(vue);
// liberer les ressources
dataAccess.Dispose();
sessionFactory.Dispose();
}
static void Main(string[] args)
{
int nbechant;
double Fe; //Frequence d echantllonnage
double Duree; // Duree du signal (en secondes)
double Te; //pas temporel d echantillonnage : Te
Console.WriteLine(" nombre d'échantillons ? ");
string rep;
rep = Console.ReadLine();
nbechant = Convert.ToInt32(rep);
//String reppad = "0";
//if ( nbechant <= 128)
//{ Console.WriteLine("-----------------------------------------------------------------");
// Console.WriteLine("nombre echantillons bas . voulez vous du 0 padding ? ");
// Console.WriteLine(" oui (1) non (0) ? ");
// Console.WriteLine("-----------------------------------------------------------------");
// reppad = Console.ReadLine();
//}
Console.WriteLine(" durée d<echantillonnage (en secondes) ? ");
rep = Console.ReadLine();
Duree = Convert.ToDouble(rep);
Te = Duree / nbechant;
Fe = 1 / Te; // frequence d echantillonnage : Fe
Console.WriteLine("-----------------------------------------------------------------");
Console.WriteLine("Frequence d echantillonnage : Fe = {0} Hz ", Fe);
//pas frequentiel
double pas;
pas = Fe / (double)nbechant;
Console.WriteLine("--------------------------------------------------------------------");
Console.WriteLine("pas de Frequence (resolution frequentielle) (axe des X pour la DFT");
Console.WriteLine("un point de mesure de DFT touts les : {0} Hz pas = {0} Hz ", pas, pas);
Console.WriteLine("---------------------------------------------------------------------");
decimal[] S2 = new decimal[nbechant];
decimal[] S3 = new decimal[nbechant];
decimal[] Si = new decimal[nbechant];
decimal[] Sign = new decimal[nbechant];
decimal[] H = new decimal[nbechant];
// Generation du signal de test suivant : avec les parametres :
// frequence dechantillonnage Fe
// nombre dechantillons : nbechant
// frequence snusoidale : 2 Khz et 2.35 Khz
//----------------------------------------------------------
// S = 1 * sin(2 * pi * Freq1 * t) + 1*sin(2 * pi * Freq2 * t)
//---------------------------------------------------------
double Freq1, Freq2;
Console.WriteLine(" frequence du signal 1 (en Hz) : 1*sin(2*pi*Freq1*t) ? ");
rep = Console.ReadLine();
Freq1 = Convert.ToDouble(rep);
Console.WriteLine(" frequence du signal 2 (en Hz): 1*sin(2*pi*Freq2*t) ? ");
rep = Console.ReadLine();
Freq2 = Convert.ToDouble(rep);
S2 = SiTest.GenSin2piF(nbechant, Freq1, 1, Fe);
S3 = SiTest.GenSin2piF(nbechant, Freq2, 1, Fe);
// signal resultant "Addition des deux signaux sinusoidaux
for (int i = 0; i < nbechant; i++)
{
Si[i] = S2[i] + S3[i];
}
Console.WriteLine(" Fenetre de Hamming (1) ou fenetre de Hanning (2) ? ");
rep = Console.ReadLine();
if (rep == "1")
{ //----------------------------------------------------
// Fenetre de Hamming
//--------------------------------------------------
H = Fenetre.HammingD(nbechant);
}
else if (rep == "2")
{ //----------------------------------------------------
// Fenetre de Hanning
//--------------------------------------------------
H = Fenetre.HanningD(nbechant);
}
// Mutiplication du signal par la fenetre choisie
//---------------------------------------------------------
for (int i = 0; i < nbechant; i++)
{
Sign[i] = Si[i] * H[i];
}
//Sauvegarde dans fichier pour v/rifications ou traitement ulterieur
//-------------------------------------------------------------------
StoficSign(Sign, "Signal.txt", Fe, nbechant);
//affichage du signal de test
//--------------------------------------------------------------------------------
PlotPython.Plot5signal("Signal.txt");
// resultat de la DFT (Discret Fourier Transform)
//----------------------------------------------------------------------------------
Complex[] Ts = new Complex[nbechant];
Ts = DFT.DFTv2(Sign);
//----------------------------------------------------------------------------
//Densite spectrale de puissance du signal
//---------------------------------------------------------------------------
decimal[] Module1 = new decimal[nbechant];
Module1 = DSP.Dspdeci(Ts);
//Sauvegarde dans fichier pour v/rifications ou traitement ulterieur
//-------------------------------------------------------------------
StoficSign(Module1, "DFT.txt", Fe, nbechant);
//plot Densite spectrale de puissance du sgignal
//------------------------------------------------------------------
PlotPython.Plot5DSP("DFT.txt");
}
public void SetFenetre(Fenetre fenetre)
{
this.fenetre = fenetre;
}
static void Main(string[] args)
{
//Preset
DimensionEtc();
int nbrGeneration = 1;
string choix = "";
Random rand = new Random();
//L'utilisateur décide du mode de jeu et de déroulement
bool pasApas = ChoixPasAPas();
int answer = ModeDeJeu();
//Generation du monde et de la GUI
int[,] game = GenerationGame(rand, answer); //CanonAPlaneur();
Fenetre gui = new Fenetre(game, 14, 0, 0, "Bienvenue dans le jeu de la vie !");
do
{
//Affichage
AfficherGameSansVisualisation(game);
AffichageInformations(game, nbrGeneration, answer, gui);
switch (answer)
{
// JEU DLV classique sans visualisation intermédiaire des états futurs
case 0:
//Passage à l'étape d'après
int[,] MatriceNbrVoisinsVivantsPopulation1rang1 = RemplissageMatriceVoisinsVivantsRang1(game, 1);
game = GameTourDaprès(game, 1, MatriceNbrVoisinsVivantsPopulation1rang1, null, null, null);
break;
// JEU DLV classique avec visualisation des états futurs (à naître et à mourir)
case 1:
//Prévisualisation
choix = PassageNextStep(pasApas);
MatriceNbrVoisinsVivantsPopulation1rang1 = RemplissageMatriceVoisinsVivantsRang1(game, 1);
ModificationPourPrevisualisation(game, MatriceNbrVoisinsVivantsPopulation1rang1, 1);
AfficherGameAvecVisualisation(game);
gui.Rafraichir();
//Passage à l'étape d'après
GameTourDApresAvecPrevisualisation(game);
break;
// JEU DLV variante (2 populations) sans visualisation des états futurs
case 2:
//Prépare l'étape d'après
MatriceNbrVoisinsVivantsPopulation1rang1 = RemplissageMatriceVoisinsVivantsRang1(game, 1);
int[,] MatriceNbrVoisinsVivantsPopulation2 = RemplissageMatriceVoisinsVivantsRang1(game, 4);
int[,] MatriceNbrVoisinVivantPopulation1rang2 = RemplissageMatriceVoisinsVivantsRang2(game, 1);
int[,] MatriceNbrVoisinVivantPopulation2rang2 = RemplissageMatriceVoisinsVivantsRang2(game, 4);
game = GameTourDaprès(game, 2, MatriceNbrVoisinsVivantsPopulation1rang1, MatriceNbrVoisinsVivantsPopulation2, MatriceNbrVoisinVivantPopulation1rang2, MatriceNbrVoisinVivantPopulation2rang2);
break;
// JEU DLV variante (2 populations) avec visualisation des états futurs
case 3:
//Prévisualisation
choix = PassageNextStep(pasApas);
MatriceNbrVoisinsVivantsPopulation1rang1 = RemplissageMatriceVoisinsVivantsRang1(game, 1);
MatriceNbrVoisinsVivantsPopulation2 = RemplissageMatriceVoisinsVivantsRang1(game, 4);
MatriceNbrVoisinVivantPopulation1rang2 = RemplissageMatriceVoisinsVivantsRang2(game, 1);
MatriceNbrVoisinVivantPopulation2rang2 = RemplissageMatriceVoisinsVivantsRang2(game, 4);
ModificationPourPrevisualisationAvec2Population(game, MatriceNbrVoisinsVivantsPopulation1rang1, MatriceNbrVoisinsVivantsPopulation2, MatriceNbrVoisinVivantPopulation1rang2, MatriceNbrVoisinVivantPopulation2rang2);
AfficherGameAvecVisualisation(game);
gui.Rafraichir();
//Prépare l'étape d'après
GameTourDApresAvecPrevisualisation(game);
break;
//Input error
default:
Console.WriteLine("\nErreur de saisi, veuillez quitter et recommencer la procédure.\n");
break;
}
//Incrémente le compteur de génération
nbrGeneration++;
//L'utilisateur passe ou non à l'étape d'après
choix = PassageNextStep(pasApas);
}while (choix != "0");
} //End static Main
static void AffichageInformations(int[,] game, int nbrGeneration, int answer, Fenetre gui)
//Cette fonction affiche la matrice dans la console, la GUI, le nombre de génération et de cellule en vie
{
//Actualise la GUI
gui.Rafraichir();
if (answer > 1)
{ //Cas où il y a 2 populations
Console.WriteLine("Nombre de génération = " + nbrGeneration + "\t");
Console.WriteLine("Nombre de cellule vivante population 1 = " + NbrCellulesVivantes(game, 1) + "\t");
Console.WriteLine("Nombre de cellule vivante population 2 = " + NbrCellulesVivantes(game, 4) + "\t");
gui.ChangerMessage("Nombre de génération = " + nbrGeneration + "\n" + "Nombre de cellule vivante population noire = " + NbrCellulesVivantes(game, 1) + "\n" + "Nombre de cellule vivante population bleue = " + NbrCellulesVivantes(game, 4));
}
else
{ //Cas où il y a 1 population
Console.WriteLine("Nombre de génération = " + nbrGeneration + "\t");
Console.WriteLine("Nombre de cellule vivante population = " + NbrCellulesVivantes(game, 1) + "\t");
gui.ChangerMessage("Nombre de génération = " + nbrGeneration + "\n" + "Nombre de cellule vivante = " + NbrCellulesVivantes(game, 1) + "\t");
}
}
static void Situation(int[,] Grille, int Visualisation, int[,] GrilleProv2, int G, Fenetre gui, int[,] MatMem)
{
int T1 = Taille(Grille, 1);
int T2 = Taille(Grille, 2);
if (Visualisation == 1)
{
gui.ChangerMessage("Nous sommes à la génération numéro " + G + " et la taille de la populaiton est de " + T1);
gui.Rafraichir();
Console.ReadKey();
}
if (Visualisation == 2)
{
gui.ChangerMessage("Nous sommes à la génération numéro " + G + " et la taille de la populaiton est de " + T1);
MatMem = CopieMatrice(Grille, MatMem); //Utilité de la mémoire
Grille = CopieMatrice(GrilleProv2, Grille);
gui.Rafraichir(); // mise à jour graphique
Console.ReadKey();
gui.ChangerMessage("Nous sommes à la génération numéro " + G + " et la taille de la population 1 est de " + T1 + " (Etape inetermédiaire)");
Grille = CopieMatrice(MatMem, Grille);//Utilisé de la mémoire
//AfficherGrille(GrilleProv2);
gui.Rafraichir();
Console.ReadKey();
}
if (Visualisation == 3) //Dans le cas des deux populations
{
gui.ChangerMessage("Nous sommes à la génération numéro " + G + " et la taille de la population 1 est de " + T1 + " et celle de la population 2 est de " + T2);
gui.Rafraichir();
Console.ReadKey();
}
if (Visualisation == 4) //Dans le cas des deux populations
{
gui.ChangerMessage("Nous sommes à la génération numéro " + G + " et la taille de la population 1 est de " + T1 + " et celle de la population 2 est de " + T2);
MatMem = CopieMatrice(Grille, MatMem); //Utilité de la mémoire
Grille = CopieMatrice(GrilleProv2, Grille);
gui.Rafraichir(); // mise à jour graphique
Console.ReadKey();
gui.ChangerMessage("Nous sommes à la génération numéro " + G + " et la taille de la population 1 est de " + T1 + " et celle de la population 2 est de " + T2 + " (Etape inetermédiaire)");
Grille = CopieMatrice(MatMem, Grille);//Utilisé de la mémoire
gui.Rafraichir();
Console.ReadKey();
//AfficherGrille(GrilleProv2);
}
}
//Jeu de la vie
static void LeJeuxDeLaVie(int[,] Grille, int Visualisation, Fenetre gui)
{
Random Generateur = new Random();
int G = 0; //Initialise la génération 0
int L = Grille.GetLength(0);
int C = Grille.GetLength(1);
bool FinDuJeu = false;
int[,] GrilleProv = new int[L, C]; //Création d'une matrice provisoire qui sert à être analyser, sans être modifier en même temps
int[,] GrilleProv2 = new int[L, C]; //Création d'une matrice provisoire qui conserve la visualisation provisoire
int[,] MatMem = new int[L, C]; //Cette matrice servira pour la visualisation intermédiaire comme matrice mémoire
while (FinDuJeu == false)
{
G++;
int taille = Taille(Grille, 0);
if (taille == 0 || GrilleProv == Grille) //Fin du jeu si c'est stabilisé
{
FinDuJeu = true;
}
else
{
GrilleProv2 = CopieMatrice(Grille, GrilleProv2); //affichage intermédiaire
GrilleProv = CopieMatrice(Grille, GrilleProv);
for (int i = 0; i < L; i++)
{
for (int j = 0; j < C; j++)
{
int compteur5 = CompterAutourCellule(GrilleProv, i, j, C, L, 1, 1); //Compte le nombre de cellule vivante autour de la cellule au rang 1 de la population 1
int compteur21 = CompterAutourCellule(GrilleProv, i, j, C, L, 2, 1); //Compte le nombre de cellule vivante autour de la cellule au rang 2 de la population 1
int compteur12 = CompterAutourCellule(GrilleProv, i, j, C, L, 1, 2); //Compte le nombre de cellule vivante autour de la cellule au rang 1 de la population 2
int compteur22 = CompterAutourCellule(GrilleProv, i, j, C, L, 2, 2); //Compte le nombre de cellule vivante autour de la cellule au rang 2 de la population 2
//==========================================================================
if (GrilleProv[i, j] == 0) //si la cellule étudiée est morte
{
if (compteur5 == 3 || compteur12 == 3)
{
GrilleProv2[i, j] = 2; //La cellule va naitre à la génératon suivante
if (Visualisation < 3)
{
Grille[i, j] = 1; //Si elle est entourée de trois cellule vivantes, alors elle nait à la génération suivante
}
else//Cas pour deux populations
{
if (compteur5 == compteur12)
{
if (compteur21 > compteur22)
{
Grille[i, j] = 1;
}
if (compteur22 > compteur21)
{
Grille[i, j] = 5;
}
if (compteur22 == compteur21)
{
Grille[i, j] = 1 + (Generateur.Next(0, 1) * 10); //Bonus
}
}
else
{
if (compteur12 == 3 || compteur12 == 2)
{
Grille[i, j] = 5;
}
else
{
Grille[i, j] = 1;
}
}
}
}
}
if (GrilleProv[i, j] == 1 || GrilleProv[i, j] == 5) //Si la cellule est vivante
{
if (Visualisation == 1 || Visualisation == 2)
{
if (compteur5 < 2)
{
GrilleProv2[i, j] = 3;
Grille[i, j] = 0; //Si elle est en sous population ou en surpopulation, alors elle meurt à la génération suivante
}
if (compteur5 > 3)
{
GrilleProv2[i, j] = 3;
Grille[i, j] = 0; //Si elle est en sous population ou en surpopulation, alors elle meurt à la génération suivante
}
}
else
{
if (compteur5 < 2 && compteur12 < 2)
{
GrilleProv2[i, j] = 3;
Grille[i, j] = 0; //Si elle est en sous population ou en surpopulation, alors elle meurt à la génération suivante
}
else
{
if (compteur5 > 3 || compteur12 > 3)
{
GrilleProv2[i, j] = 3;
Grille[i, j] = 0; //Si elle est en sous population ou en surpopulation, alors elle meurt à la génération suivante
}
}
}
}
if (GrilleProv[i, j] == 5) //Si la cellule est vivante de la population 2
{
if (compteur5 < 2)
{
GrilleProv2[i, j] = 3;
Grille[i, j] = 0; //Si elle est en sous population ou en surpopulation, alors elle meurt à la génération suivante
}
if (compteur5 > 3)
{
GrilleProv2[i, j] = 3;
Grille[i, j] = 0; //Si elle est en sous population ou en surpopulation, alors elle meurt à la génération suivante
}
}
}
FinDuJeu = false;
}
Situation(Grille, Visualisation, GrilleProv2, G, gui, MatMem);
//AfficherGrille(Grille); //Enlever les // pour remettre sur la console, mais vu qu'on utilise le GUI, nous n'en avons pas besoin
}
}
Console.Write("Fin du Jeu ..... Youpi");
}
static void Main(string[] args)
{
int h = 1;
do
{
Console.Clear();
Console.WriteLine("Bienvenue au Jeu de la Vie !\n");
Console.WriteLine("Saisir une valeur de remplissage : (entre 0,1 ou 1)");
double remplissage = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Saisir un nombre de lignes : ");
int ligne = Convert.ToInt16(Console.ReadLine());
Console.WriteLine("Saisir un nombre de colonnes : ");
int colonne = Convert.ToInt16(Console.ReadLine());
Console.WriteLine("Voulez-vous activer le bonus de la variante de la règle R4B ? (oui/non)");
string varianteR4B = Convert.ToString(Console.ReadLine());
if (varianteR4B == "oui")
{
Console.WriteLine("Bonus règle R4B activé !\n");
}
else
{
Console.WriteLine("Bonus règle R4B désactivé !\n");
}
Console.WriteLine("Voulez-vous activer le bonus de l'état stable ? (oui/non)");
string etatStable = Convert.ToString(Console.ReadLine());
int nbrEtatAStabiliser = 99999999;
if (etatStable == "oui")
{
Console.WriteLine("Bonus état stable activé !");
Console.WriteLine("Pour combien d'états voulez-vous vérifier la stabilité ?");
nbrEtatAStabiliser = Convert.ToInt16(Console.ReadLine());
}
else
{
Console.WriteLine("Bonus état stable désactivé !");
}
string g = "";
int compteurGeneration = 1;
string etatsInter = "";
Console.Clear();
Console.WriteLine("Voulez vous afficher les etats intermediaires ? (oui/non)");
etatsInter = Convert.ToString(Console.ReadLine());
Console.WriteLine("Choisissez le mode de jeu : ");
Console.WriteLine("Une seule population > 1 ");
Console.WriteLine("Deux populations adverses > 2 ");
int choixMode = Convert.ToInt16(Console.ReadLine());
if (choixMode == 1)
{
int[,] grille = Grille(ligne, colonne, remplissage);
int[,] grilleAfficher = new int[grille.GetLength(0), grille.GetLength(1)];
for (int i = 0; i < grille.GetLength(0); i++)
{
for (int j = 0; j < grille.GetLength(1); j++)
{
grilleAfficher[i, j] = grille[i, j];
}
}
Fenetre gui = new Fenetre(grilleAfficher, 15, 0, 0, "Jeu de la vie");
int compteurStabilisation = 0;
do
{
int nombreCellulesVivantes = CompteurCellulesVivantes(grille);
Console.Clear();
AfficherGrille(grille); //Affiche la grille de la nouvelle generation dans la console.
Console.WriteLine("Generation n :" + compteurGeneration); //Donne le numero de generation
Console.WriteLine("Il y a " + CompteurCellulesVivantes(grille) + " cellules vivantes"); // Affiche un compteur du nombre de cellules vivantes a la generation donnee.
gui.changerMessage("Il y a " + CompteurCellulesVivantes(grille) + " cellules vivantes");
if (etatsInter == "oui")
{
Console.WriteLine("Appuyer sur une touche pour continuer");
Console.ReadKey();
Console.Clear();
//Cree une grille intermediaire.
int[,] grilleInter = GrilleEtatInter(grille);
AfficherGrille(grilleInter);
for (int i = 0; i < grille.GetLength(0); i++)
{
for (int j = 0; j < grille.GetLength(1); j++)
{
grilleAfficher[i, j] = grilleInter[i, j];
}
}
gui.RafraichirTout();
}
Console.WriteLine("Appuyer sur Entree pour passer a la generation suivante, ou saisissez 'stop' pour arreter");
g = Convert.ToString(Console.ReadLine());
grille = NewGrille(grille);
for (int i = 0; i < grille.GetLength(0); i++)
{
for (int j = 0; j < grille.GetLength(1); j++)
{
grilleAfficher[i, j] = grille[i, j];
}
}
gui.RafraichirTout();
if (nombreCellulesVivantes == CompteurCellulesVivantes(grille))
{
compteurStabilisation++;
}
else
{
compteurStabilisation = 0;
}
if (compteurStabilisation == nbrEtatAStabiliser)
{
g = "stop";
Console.WriteLine("La generation est stable depuis " + nbrEtatAStabiliser + " generations. On peut donc arreter le programme.");
}
compteurGeneration++;
} while (g == "");
}
if (choixMode == 2)
{
int[,] grille = Grille1v1(ligne, colonne, remplissage);
int[,] grilleAfficher = new int[grille.GetLength(0), grille.GetLength(1)];
for (int i = 0; i < grille.GetLength(0); i++)
{
for (int j = 0; j < grille.GetLength(1); j++)
{
grilleAfficher[i, j] = grille[i, j];
}
}
Fenetre gui = new Fenetre(grilleAfficher, 15, 0, 0, "Jeu de la vie");
int compteurStabilisation = 0;
do
{
int nombreCellulesVivantes = CompteurCellulesVivantes(grille);
Console.Clear();
AfficherGrille(grille); //affiche la grille de la nouvelle generation dans la console.
Console.WriteLine("Génération n :" + compteurGeneration); //donne le numero de generation
Console.WriteLine("Il y a " + CompteurCellulesVivantes(grille) + " cellules vivantes"); // affiche un compteur du nombre de cellules vivantes a la génération donnee.
gui.changerMessage("Il y a " + CompteurCellulesVivantes(grille) + " cellules vivantes");
if (etatsInter == "oui")
{
Console.WriteLine("Appuyer sur une touche pour continuer");
Console.ReadKey();
Console.Clear();
//crée une grille intermédiaire.
int[,] grilleInter = GrilleEtatInter1v1(grille);
AfficherGrille(grilleInter);
for (int i = 0; i < grille.GetLength(0); i++)
{
for (int j = 0; j < grille.GetLength(1); j++)
{
grilleAfficher[i, j] = grilleInter[i, j];
}
}
gui.RafraichirTout();
}
Console.WriteLine("Appuyer sur Entrée pour passer a la génération suivante, ou saisissez 'stop' pour arrêter");
g = Convert.ToString(Console.ReadLine());
grille = NewGrille1v1(grille, varianteR4B);
for (int i = 0; i < grille.GetLength(0); i++)
{
for (int j = 0; j < grille.GetLength(1); j++)
{
grilleAfficher[i, j] = grille[i, j];
}
}
gui.RafraichirTout();
if (nombreCellulesVivantes == CompteurCellulesVivantes(grille))
{
compteurStabilisation++;
}
else
{
compteurStabilisation = 0;
}
if (compteurStabilisation == nbrEtatAStabiliser)
{
g = "stop";
Console.WriteLine("La grille est stable depuis " + nbrEtatAStabiliser + " générations. On peut donc arrêter le programme.");
}
compteurGeneration++;
} while (g == "");
}
Console.WriteLine("Voulez vous recommencer ou fermer le programme\n 1 : Recommencer\n 2: Fermer\n");
h = Convert.ToInt16(Console.ReadLine());
} while (h != 2);
}
/// <summary>
/// public override void sourisGaucheRelachee(MouseEventArgs e)
///
/// Cette fonction met à jour la rotation de la sélection
/// </summary>
/// <param name="e">
/// L'évènement relié au relâchement du bouton gauche de la souris
/// </param>
public override void SourisGaucheRelachee(MouseEventArgs e)
{
Fenetre.MettreAJourRotation();
base.SourisGaucheRelachee(e);
}
[STAThread()] // on utilise esilvGUI, esilvGUI est basé sur winForms, et la plateforme winForms nécéssite que tout les controlleurs soient géré par un et un seul Thread, STAThread (STA : Single-Threaded Apartment) permet de forcer le code a n'utiliser qu'un seul thread a l'inverse de la commande MTAThread.
static void Main()
{
dynamic[] param = RecupererParametre(); // la fonction RecupererParametre renvoit un tableau d'objet dynamique, cela peut etre des ints, des doubles, ou tout autre type possible. Cela a à la fois des avantages et des inconvéniants, ça à l'avantage de pouvoir renvoyer tout type de variable sans devoir se focaliser sur un seul type (ex: utiliser des strings pour des valeurs qui étaient des ints et des bools), mais ça à comme incovéniant majeur que le compilateur ne peut pas vérifier si on essaye pas d'attribuer une valeur booléenne à une variable int.
int x = param[0];
int y = param[1];
int versionChoice = param[2];
double tauxContamination = param[3];
double[] poidsStat = param[4];
double tauxConfinement = param[5];
int tailleCase = param[6];
double tauxGuerison = param[7];
int nombrePatientsZero = param[8];
stadeDeconfinement = param[9];
InitGrille(x, y, nombrePatientsZero, tauxConfinement);
gui = new Fenetre(grille, tailleCase, 0, 0, "Jeu de la vie - COVID");
AfficherMatrice(grille);
Console.ReadKey();
bool stop = false;
while (!stop)
{
grilleTemp = grille.Clone() as int[, ]; // grilleTemp est la grille sur laquelle on va faire les modifications d'évolution avant de les appliquer sur grille pour eviter les conflits et on ne peut pas modifier grille directement puisqu'on s'appuit sur grille pour determiner l'évolution.
for (int i = 0; i < x; i++)
{
for (int j = 0; j < y; j++)
{
Evoluer(i, j, tauxContamination, poidsStat, tauxGuerison);
}
}
for (int i = 0; i < x; i++)
{
for (int j = 0; j < y; j++)
{
grille[i, j] = grilleTemp[i, j];
}
}
//Console.WriteLine("apres");
//AfficherMatrice(grille);
gui.RafraichirTout();
int[] pop = Population();
gui.changerMessage("Génération " + gen + " | sains non-immunisés : " + pop[0] + " | sains immunisés : " + pop[6] + " | stade 0 : " + pop[1] + " | stade 1 : " + pop[2] + " | stade 2 : " + pop[3] + " | stade 3 : " + pop[4] + " | morts : " + pop[5] + " | confinés : " + pop[7]);
System.Threading.Thread.Sleep(500);
//Console.ReadKey();
gen++;
if (pop[1] == 0 && pop[2] == 0 && pop[3] == 0 && pop[4] == 0)
{
//il n'y a plus de malade, on a atteint la stabilité
stop = true;
}
}
Console.ReadKey();
}
static void Main(string[] args)
{
string argument;
// script python a executer pour ploter les resultats
//-------------------------------------------------
argument = "C:\\C#\\MathsLib\\Test_sysarg-v4.py" + " ";
int nbechant;
double Fe; //Frequence d echantllonnage
//calcul de la frequence d echantillonnage FE
//sampling frequency of Fe Hz and a signal duration of 2 secondes. avec une fréquence d'échantillonnage de Fe
nbechant = 256;
double Duree = 0.05; // 0.05 secondes
double Te; //pas temporel d echantillonnage : Te
Te = Duree / nbechant;
Fe = 1 / Te; // frequence d echantillonnage : Fe
Console.WriteLine("Frequence d echantillonnage : Fe = {0}", Fe);
decimal[] S2 = new decimal[nbechant];
decimal[] S3 = new decimal[nbechant];
decimal[] Si = new decimal[nbechant];
decimal[] Sign = new decimal[nbechant];
decimal[] H = new decimal[nbechant];
// Generation du signal de test suivant : avec les parametres :
// frequence dechantillonnage Fe
// nombre dechantillons : nbechant
// frequence snusoidale : 2 Khz et 2.35 Khz
//----------------------------------------------------------
// S = 1 * sin(2 * pi * 2000 * t) + 1*sin(2 * pi * 2350 * t)
//---------------------------------------------------------
S2 = SiTest.GenSin2piF(nbechant, 2000, 1, Fe);
S3 = SiTest.GenSin2piF(nbechant, 2350, 1, Fe);
// signal resultant "Addition des deux signaux sinusoidaux
for (int i = 0; i < nbechant; i++)
{
Si[i] = S2[i] + S3[i];
}
//----------------------------------------------------
// Fenetre de Hamming
//--------------------------------------------------
H = Fenetre.HammingD(nbechant);
// Mutiplication du signal par la fenetre de Hamming
for (int i = 0; i < nbechant; i++)
{
Sign[i] = Si[i] * H[i];
}
//--------------------------------------------------------------------------------
// resultat de la DFT (Discret Fourier Transform)
//----------------------------------------------------------------------------------
Complex[] Ts = new Complex[nbechant];
Ts = DFT.DFTv2(Sign);
//----------------------------------------------------------------------------
//Densite spectrale de puissance du signal
//---------------------------------------------------------------------------
decimal[] Module1 = new decimal[nbechant];
Module1 = DSP.Dspdeci(Ts);
//Magnitude du signal
//------------------------------------------
decimal[] Module2 = new decimal[nbechant];
Module2 = DFT.DspMagnDec(Ts);
//plot signal de test :
//-------------------------------------------------------------------
PlotPython.Plot1(Si, argument);
//plot signal multiplié parla fenetre de Hamming
//-------------------------------------------------------------------
PlotPython.Plot1(Sign, argument);
//plot Densite spectrale de puissance du sgignal
//------------------------------------------------------------------
PlotPython.Plot1(Module1, argument);
//plot MAgnitude du sgignal
//------------------------------------------------------------------
PlotPython.Plot1(Module2, argument);
}
