private void ChargementOptions(Options option)
{
switch (option.Difficulte)
{
case "Facile":
difficulte = new Facile();
break;
case "Normal":
difficulte = new Normal();
break;
case "Difficile":
difficulte = new Difficile();
break;
}
switch (option.ChoixDevice)
{
case "LeapMotion":
HandPosition.enable = true;
MousePosition.enable = false;
break;
default:
HandPosition.enable = false;
MousePosition.enable = true;
break;
}
Animation_Taupe.vitesseAnim = difficulte.VitesseAnimTaupe;
Collision_Taupe.nbTempsGagne = difficulte.TimeMultiplier;
Collision_Taupe.nbPoints = difficulte.ScoreMultiplier;
Spawner.CoeffJaune = difficulte.CoeffTaupeJaune;
Spawner.CoeffRouge = difficulte.CoeffTaupeRouge;
}
/// <summary>
/// Méthode démarrant les variables du jeu
/// </summary>
public override void StartGame()
{
_nombreToursTotal = 29;
_nombreTours = 0;
CompteurErreurs = 0;
_listeCouleur.Add(new Element <string, SolidColorBrush>(ResourceLoader.GetForCurrentView().GetString("Rouge"), new SolidColorBrush(Color.FromArgb(255, 255, 0, 0))));
_listeCouleur.Add(new Element <string, SolidColorBrush>(ResourceLoader.GetForCurrentView().GetString("Jaune"), new SolidColorBrush(Color.FromArgb(255, 255, 255, 0))));
_listeCouleur.Add(new Element <string, SolidColorBrush>(ResourceLoader.GetForCurrentView().GetString("Noir"), new SolidColorBrush(Color.FromArgb(255, 0, 0, 0))));
_listeCouleur.Add(new Element <string, SolidColorBrush>(ResourceLoader.GetForCurrentView().GetString("Bleu"), new SolidColorBrush(Color.FromArgb(255, 0, 0, 255))));
if (Difficulte.Equals(DifficulteEnum.MOYEN) || Difficulte.Equals(DifficulteEnum.DIFFICILE))
{
_listeCouleur.Add(new Element <string, SolidColorBrush>(ResourceLoader.GetForCurrentView().GetString("Orange"), new SolidColorBrush(Color.FromArgb(255, 255, 104, 0))));
_listeCouleur.Add(new Element <string, SolidColorBrush>(ResourceLoader.GetForCurrentView().GetString("Violet"), new SolidColorBrush(Color.FromArgb(255, 170, 0, 255))));
}
if (Difficulte.Equals(DifficulteEnum.DIFFICILE))
{
_listeCouleur.Add(new Element <string, SolidColorBrush>(ResourceLoader.GetForCurrentView().GetString("Rose"), new SolidColorBrush(Color.FromArgb(255, 244, 114, 208))));
_listeCouleur.Add(new Element <string, SolidColorBrush>(ResourceLoader.GetForCurrentView().GetString("Vert"), new SolidColorBrush(Color.FromArgb(255, 96, 169, 23))));
}
StartChrono();
}
/// <summary>
/// Génère un signe d'opération pour un calcul
/// </summary>
/// <returns>le type d'opération</returns>
private OperationEnum GetSigneOperation()
{
int valMax;
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
valMax = 4;
}
else if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
valMax = 4;
}
else
{
valMax = 5;
}
int value;
do
{
value = _random.Next(valMax);
} while (value == 0);
OperationEnum retour;
System.Enum.TryParse(value.ToString(), out retour);
return(retour);
}
// Initialize components
public JouerQuiz(Utilisateur utilisateur, Matiere matiere, Difficulte difficulte)
{
InitializeComponent();
this.matiere = matiere;
currentQuestion = -1;
questions = new List <Question>();
quiz = new Quiz();
quiz.score = 0;
quiz.Utilisateur = utilisateur;
quiz.Matiere = matiere;
quiz.dateQuiz = DateTime.Now;
switch (difficulte)
{
case Difficulte.Difficile:
NBR_QUESTION = 300;
break;
case Difficulte.Moyen:
NBR_QUESTION = 80;
break;
}
txtTrueQuestion.Text = "Passé " + (nbrWrongQuestion + nbrTrueQuestion) + " / " + NBR_QUESTION;
txtWrongQuestion.Text = "Incorrect " + nbrWrongQuestion + " / " + NBR_QUESTION;
this.Activate();
}
/// <summary>
/// Génère l'emplacement des lettres de l'aplahabet à retrouver
/// </summary>
public void GenererAlphabet()
{
int nbLettres;
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
nbLettres = 10;
}
else if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
nbLettres = 20;
}
else
{
nbLettres = 25;
}
ListeLettre = new List <char>(nbLettres * 2);
NbReponsesAttendue = nbLettres;
//liste des lettres
var listeA = new List <char>(nbLettres);
for (var i = 0; i < nbLettres; i++)
{
listeA.Add((char)(i + 65));
}
//liste des emplacements
var listeB = new List <int>(nbLettres * 2);
for (var i = 0; i < nbLettres * 2; i++)
{
listeB.Add(i);
ListeLettre.Add(' ');
}
do
{
//choix aléatoire d'une lettre à placer
var lettreAleatoire = listeA[_random.Next(0, listeA.Count)];
//choix aléatoire de deux position
var positionA = listeB[_random.Next(0, listeB.Count)];
int positionB;
int pos;
do
{
pos = listeB[_random.Next(0, listeB.Count)];
} while (positionA == pos);
positionB = pos;
//insertion de la lettre dans les 2 positions
ListeLettre[positionA] = lettreAleatoire;
ListeLettre[positionB] = lettreAleatoire;
listeA.Remove(lettreAleatoire);
listeB.Remove(positionA);
listeB.Remove(positionB);
} while (listeA.Count != 0);
}
/// <summary>
/// Genere la première ligne de chiffre du tricalcul et les opérations de tours les lignes
/// </summary>
public void GenererOperation()
{
LigneChiffre.Clear();
_premiereLigneOperation.Clear();
_deuxiemeLigneOperation.Clear();
_troisiemeLigneOperation.Clear();
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
for (var i = 0; i < 3; i++)
{
LigneChiffre.Add(_random.Next(1, 11));
}
_deuxiemeLigneOperation.Add(OperationEnum.Addition);
_deuxiemeLigneOperation.Add(OperationEnum.Addition);
_troisiemeLigneOperation.Add(OperationEnum.Addition);
_resultatAttendu = (LigneChiffre[0] + LigneChiffre[1]) + (LigneChiffre[1] + LigneChiffre[2]);
}
else if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
for (var i = 0; i < 4; i++)
{
LigneChiffre.Add(_random.Next(1, 11));
}
_premiereLigneOperation.Add(OperationEnum.Addition);
_premiereLigneOperation.Add(OperationEnum.Addition);
_premiereLigneOperation.Add(OperationEnum.Addition);
_deuxiemeLigneOperation.Add(OperationEnum.Addition);
_deuxiemeLigneOperation.Add(OperationEnum.Addition);
_troisiemeLigneOperation.Add(OperationEnum.Addition);
var resA = LigneChiffre[0] + LigneChiffre[1];
var resB = LigneChiffre[1] + LigneChiffre[2];
var resC = LigneChiffre[2] + LigneChiffre[3];
_resultatAttendu = (resA + resB) + (resB + resC);
}
else
{
for (var i = 0; i < 4; i++)
{
LigneChiffre.Add(_random.Next(1, 11));
}
_premiereLigneOperation.Add(GetSigneOperation());
_premiereLigneOperation.Add(GetSigneOperation());
_premiereLigneOperation.Add(GetSigneOperation());
_deuxiemeLigneOperation.Add(OperationEnum.Addition);
_deuxiemeLigneOperation.Add(OperationEnum.Addition);
_troisiemeLigneOperation.Add(OperationEnum.Addition);
var resA = (_premiereLigneOperation[0].Equals(OperationEnum.Addition)) ? LigneChiffre[0] + LigneChiffre[1] : LigneChiffre[0] * LigneChiffre[1];
var resB = (_premiereLigneOperation[1].Equals(OperationEnum.Addition)) ? LigneChiffre[1] + LigneChiffre[2] : LigneChiffre[1] * LigneChiffre[2];
var resC = (_premiereLigneOperation[2].Equals(OperationEnum.Addition)) ? LigneChiffre[2] + LigneChiffre[3] : LigneChiffre[2] * LigneChiffre[3];
_resultatAttendu = (resA + resB) + (resB + resC);
}
}
public override int GetHashCode()
{
var hashCode = -674022627;
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(NomZone);
hashCode = hashCode * -1521134295 + Numero.GetHashCode();
hashCode = hashCode * -1521134295 + Difficulte.GetHashCode();
return(hashCode);
}
/// <summary>
/// Calcul du résultat et fin du jeu
/// </summary>
/// <returns>les résultats à afficher pour les scores</returns>
public async override Task <Resultats> CalculResult()
{
StopChrono();
//calcul de l'age pour connaitre la marge de temps à rajouter au temps min
var age = DateUtils.IntervalleEntreDeuxDatesAnnee(ContextAppli.ContextUtilisateur.EnCoursUser.DateNaissance, DateUtils.GetMaintenant());
var nbMilisecAge = (age < 30) ? 0 : (((age - 20) / 10) * 1500);
//calcul de l'interval de temps de résolution du jeu en fonction de l'age et de la diffculté
var tempsMin = (5000 + nbMilisecAge) * _nombreTours;
var tempsMax = 0;
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
tempsMin = (6000 + nbMilisecAge) * _nombreTours;
tempsMax = (20000 + (nbMilisecAge * 3)) * _nombreTours;
}
if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
tempsMin = (5000 + nbMilisecAge) * _nombreTours;
tempsMax = (15000 + (nbMilisecAge * 3)) * _nombreTours;
}
if (Difficulte.Equals(DifficulteEnum.DIFFICILE))
{
tempsMin = (4000 + nbMilisecAge) * _nombreTours;
tempsMax = (10000 + (nbMilisecAge * 3)) * _nombreTours;
}
//calcul de la note de temps
int noteTemps;
if (TempsPasse <= tempsMin)
{
noteTemps = 100;
}
else if (TempsPasse >= tempsMax)
{
noteTemps = 0;
}
else
{
noteTemps = 100 - ((TempsPasse - tempsMin) / ((tempsMax - tempsMin) / 100));
}
//prise en comtpe des erreurs
var noteAvecErreurs = 100 - ((CompteurErreurs * 100) / _nombreTours);
//calcul de la note finale et sauvegarde
return(await SaveResult((noteAvecErreurs <= 0)? 0 : ((noteTemps * 3) + noteAvecErreurs) / 4));
}
public static DifficulteModel ToModel(this Difficulte bo)
{
if (bo == null)
{
return(null);
}
return(new DifficulteModel
{
Id = bo.Id,
Libelle = bo.Libelle
});
}
public Model()
{
employes.add(new List <Receptionniste>());
employes.add(new List <Coffrier>());
employes.add(new List <Tresorier>());
employes.add(new List <Tamponeur>());
employes.add(new List <Chef>());
difficulte = new Difficulte(5, 40, 5); //Predecl pour diff facile
requetesFlot = new Timer(difficulte.getDebitRequetes());
requetesFlot.Elapsed += generateRequest();
requetesFlot.start();
}
static string ObtenirLibellePourNiveau(Difficulte difficulte)
{
switch (difficulte)
{
case Difficulte.Facile:
return(Message.Diff1);
case Difficulte.Normal:
return(Message.Diff2);
case Difficulte.Difficile:
return(Message.Diff3);
}
return(Message.Diff1);
}
/// <summary>
/// calcul du score
/// </summary>
/// <returns></returns>
public override async Task <Resultats> CalculResult()
{
//calcul de l'age pour connaitre la marge de temps à rajouter au temps min
var age = DateUtils.IntervalleEntreDeuxDatesAnnee(ContextAppli.ContextUtilisateur.EnCoursUser.DateNaissance, DateUtils.GetMaintenant());
var nbMilisecAge = (age < 30) ? 0 : (((age - 20) / 10) * 5000);
//calcul de l'interval de temps de résolution du jeu en fonction de l'age et de la diffculté
var tempsMin = (50000 + nbMilisecAge) * _nbTours;
var tempsMax = 0;
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
tempsMax = (90000 + nbMilisecAge) * _nbTours;
}
if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
tempsMax = (100000 + nbMilisecAge) * _nbTours;
}
if (Difficulte.Equals(DifficulteEnum.DIFFICILE))
{
tempsMax = (120000 + nbMilisecAge) * _nbTours;
}
//calcul de la note de temps
int noteTemps;
if (TempsPasse <= tempsMin)
{
noteTemps = 100;
}
else if (TempsPasse >= tempsMax)
{
noteTemps = 0;
}
else
{
noteTemps = 100 - ((TempsPasse - tempsMin) / ((tempsMax - tempsMin) / 100));
}
//pénalité des indices
noteTemps = noteTemps - (2 * _compteurIndiceTotal);
noteTemps = noteTemps <= 0 ? 15 : noteTemps;
//calcul de la note finale et sauvegarde
return(await SaveResult(noteTemps));
}
public async override Task <Resultats> CalculResult()
{
StopChrono();
//calcul de l'age pour connaitre la marge de temps à rajouter au temps min
var age = DateUtils.IntervalleEntreDeuxDatesAnnee(ContextAppli.ContextUtilisateur.EnCoursUser.DateNaissance, DateUtils.GetMaintenant());
var nbMilisecAge = (age < 30) ? 0 : (((age - 20) / 10) * 10000);
int tempsMin;
int tempsMax;
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
tempsMin = (45000 + nbMilisecAge);
tempsMax = (240000 + nbMilisecAge);
}
else if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
tempsMin = (130000 + nbMilisecAge);
tempsMax = (400000 + nbMilisecAge);
}
else
{
tempsMin = (160000 + nbMilisecAge);
tempsMax = (420000 + nbMilisecAge);
}
//calcul de la note de temps
int noteTemps;
if (TempsPasse <= tempsMin)
{
noteTemps = 100;
}
else if (TempsPasse >= tempsMax)
{
noteTemps = 0;
}
else
{
noteTemps = 100 - ((TempsPasse - tempsMin) / ((tempsMax - tempsMin) / 100));
}
//calcul de la note finale et sauvegarde
return(await SaveResult(noteTemps));
}
/// <summary>
/// Fin du jeu et calcul du résultat
/// </summary>
/// <returns>les résultats à afficher</returns>
public async override Task <Resultats> CalculResult()
{
StopChrono();
//calcul de l'age pour connaitre la marge de temps à rajouter au temps min
var age = DateUtils.IntervalleEntreDeuxDatesAnnee(ContextAppli.ContextUtilisateur.EnCoursUser.DateNaissance, DateUtils.GetMaintenant());
var nbMilisecAge = (age < 30) ? 0 : (((age - 20) / 10) * 300);
var tempsMax = 0;
var tempsMin = (TempsApparition + nbMilisecAge + 3000 + 2500) * _nbTours;
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
tempsMax = (TempsApparition + nbMilisecAge + 3000 + 4000) * _nbTours;
}
if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
tempsMax = (TempsApparition + nbMilisecAge + 3000 + 3500) * _nbTours;
}
if (Difficulte.Equals(DifficulteEnum.DIFFICILE))
{
tempsMax = (TempsApparition + nbMilisecAge + 3000 + 3000) * _nbTours;
}
//calcul de la note de temps
int noteTemps;
if (TempsPasse <= tempsMin)
{
noteTemps = 100;
}
else if (TempsPasse >= tempsMax)
{
noteTemps = 0;
}
else
{
noteTemps = 100 - ((TempsPasse - tempsMin) / ((tempsMax - tempsMin) / 100));
}
//prise en compte des erreurs
var noteAvecErreurs = ((_nbTours - CompteurErreurs) * noteTemps) / _nbTours;
return(await SaveResult((noteAvecErreurs <= 0)? 0 : ((noteTemps * 3) + noteAvecErreurs) / 4));
}
/// <summary>
/// Genere les deux horloges et calcul la différence entre les deux
/// </summary>
public void GenererHeure()
{
var heureA = _random.Next(0, 12);
var minuteA = _random.Next(0, 60);
//si c'est en faciel ou moyen, on arrondi à heure finissant par 5 ou zero
if (!Difficulte.Equals(DifficulteEnum.DIFFICILE) && minuteA % 5 != 0)
{
do
{
minuteA++;
} while (minuteA % 5 != 0);
if (minuteA >= 60)
{
minuteA = 55;
}
}
var heureB = _random.Next(0, 12);
var minuteB = _random.Next(0, 60);
if (!Difficulte.Equals(DifficulteEnum.DIFFICILE) && minuteB % 5 != 0)
{
do
{
minuteB++;
} while (minuteB % 5 != 0);
if (minuteB >= 60)
{
minuteB = 55;
}
}
var heureFin = DateUtils.AdditionHeure(heureA, minuteA, heureB, minuteB);
HeureA = ((heureA.ToString().Length < 2)?"0" + heureA:heureA.ToString()) + " : " + ((minuteA.ToString().Length < 2) ? "0" + minuteA : minuteA.ToString());
HeureB = ((heureFin.Hours.ToString().Length < 2) ? "0" + heureFin.Hours : heureFin.Hours.ToString()) + " : " + ((heureFin.Minutes.ToString().Length < 2) ? "0" + heureFin.Minutes : heureFin.Minutes.ToString());
_differenceHeure = heureB;
_differenceMinute = minuteB;
}
/// <summary>
/// trouve une liste de mots aléatoire à afficher
/// </summary>
public async Task GenererMots()
{
//ouverture du fichier et récupération des mots
var file = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(@"Rsc\mots\liste" + ListeLangues.GetLangueEnCours().Diminutif + ".txt");
var listeMots = (await FileIO.ReadLinesAsync(file)).Where(x => x.Length <= 7 && x.Length >= 4).ToList();
var nbMots = 0;
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
nbMots = 15;
}
else if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
nbMots = 21;
}
else
{
nbMots = 30;
}
//sélection de 30 aléatoire
var increment = 0;
do
{
string motTmp;
do
{
var nb = _random.Next(listeMots.Count);
motTmp = listeMots[nb];
} while (MotsAleatoire.Contains(motTmp));
MotsAleatoire.Add(motTmp);
increment++;
} while (increment < nbMots);
//pour comparer plus vite les mots formatter on les stocks simplifier
foreach (var mot in MotsAleatoire)
{
_motsAleatoireFormater.Add(StringUtils.SupprimerCaracSpeciaux(mot.ToLower()));
}
}
/// <summary>
/// charge à partir du fichier la liste des mots à utilsier
/// </summary>
/// <returns></returns>
public async Task ChargeListeMots()
{
var file = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(@"Rsc\mots\listeb" + ListeLangues.GetLangueEnCours().Diminutif + ".txt");
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
_listeMots = (await FileIO.ReadLinesAsync(file)).Where(x => x.Length <= 8 && x.Length >= 5).ToList();
}
if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
_listeMots = (await FileIO.ReadLinesAsync(file)).Where(x => x.Length <= 13 && x.Length >= 5).ToList();
}
if (Difficulte.Equals(DifficulteEnum.DIFFICILE))
{
_listeMots = (await FileIO.ReadLinesAsync(file)).Where(x => x.Length <= 20 && x.Length >= 10).ToList();
}
StartChrono();
}
public override void LoadContent()
{
_loading2D = ScreenManager.Game.Content.Load <Texture2D>("loading");
continuer_2D = ScreenManager.Game.Content.Load <Texture2D>("Bouton/bouton_valider");
mots = ScreenManager.Game.Content.Load <SpriteFont>("blabla");
blabla = ScreenManager.Game.Content.Load <SpriteFont>("Transition");
dictionnaire10 = ScreenManager.Game.Content.Load <Dictionnaire>(lang.path + "dico10");
dictionnaire9 = ScreenManager.Game.Content.Load <Dictionnaire>(lang.path + "dico9");
dictionnaire8 = ScreenManager.Game.Content.Load <Dictionnaire>(lang.path + "dico8");
dictionnaire7 = ScreenManager.Game.Content.Load <Dictionnaire>(lang.path + "dico7");
dictionnaire6 = ScreenManager.Game.Content.Load <Dictionnaire>(lang.path + "dico6");
dictionnaire5 = ScreenManager.Game.Content.Load <Dictionnaire>(lang.path + "dico5");
dictionnaire4 = ScreenManager.Game.Content.Load <Dictionnaire>(lang.path + "dico4");
IA_DIFF = ScreenManager.Game.Content.Load <Difficulte>("Difficulte");
langue = ScreenManager.Game.Content.Load <Langues>(lang.path + "LANG");
InitilizeLanguages();
save = xmls.DeserializeSauvegarde();
base.LoadContent();
}
public override void LoadContent()
{
plaque_choix = ScreenManager.Game.Content.Load <Texture2D>("Bouton/bouton_blanc");
plaque_lettre = ScreenManager.Game.Content.Load <Texture2D>("Lettres/plaque_lettre");
valider = ScreenManager.Game.Content.Load <Texture2D>("Chiffre/valider");
effacer = ScreenManager.Game.Content.Load <Texture2D>("Chiffre/effacer");
fond_timer = ScreenManager.Game.Content.Load <Texture2D>("fond_bar");
barre_timer = ScreenManager.Game.Content.Load <Texture2D>("progress-bar");
Lettre_plaque_font = ScreenManager.Game.Content.Load <SpriteFont>("chiffre_font");
blabla = ScreenManager.Game.Content.Load <SpriteFont>("Transition");
bouton = ScreenManager.Game.Content.Load <SpriteFont>("bouton");
langue = ScreenManager.Game.Content.Load <Langues>(lang.path + "LANG");
InitilizeLanguages();
if (_typepartie == 4)
{
diff = ScreenManager.Game.Content.Load <Difficulte>("Difficulte"); save = xmls.DeserializeSauvegarde();
}
base.LoadContent();
}
static void NouvellePartie()
{
Console.Clear();
score = 0;
lettresJouees.Clear();
difficulte = DemanderDifficulte();
Console.Clear();
Console.WriteLine(Message.DispDifficulte, prenom, ObtenirLibellePourNiveau(difficulte));
mot = ChoisirMotAleatoirement();
while (ConstruireMotPourAffichage().Contains("_") && pointsVie > 0)
{
DemandeLettreJoueur();
}
if (pointsVie == 0)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(Message.FinFalse, prenom, mot);
Console.ForegroundColor = ConsoleColor.White;
}
else
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(Message.FinTrue, prenom, mot, score, score > 1 || score < -1 ? "s" : "");
Console.ForegroundColor = ConsoleColor.White;
if (score <= Properties.Settings.Default.MeilleurScore)
{
Console.WriteLine(Message.DispMeilleurScore, Properties.Settings.Default.MeilleurScore);
}
else
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(Message.NouveauMeilleurScore, Properties.Settings.Default.MeilleurScore);
Properties.Settings.Default.MeilleurScore = score;
Properties.Settings.Default.Save();
Console.ForegroundColor = ConsoleColor.White;
}
}
}
/// <summary>
/// Démarrage du jeu
/// </summary>
public override void StartGame()
{
_niveau = 1;
_nbTours = 8;
_tours = 0;
CompteurErreurs = 0;
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
TempsApparition = 2000;
}
if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
TempsApparition = 1600;
}
if (Difficulte.Equals(DifficulteEnum.DIFFICILE))
{
TempsApparition = 1100;
}
StartChrono();
}
/// <summary>Crée une partie et lui assigne un joueur.</summary>
/// <param name="joueur">Joueur assisgné à la partie</param>
/// <param name="difficulte">Niveau de difficulté de la partie</param>
/// <param name="taille">Taille du plateau de la partie</param>
/// <exception cref="ArgumentNullException">Le joueur assigné à la partie ne peut pas être la valeur null</exception>
public Partie(Joueur joueur, Difficulte difficulte, Taille taille)
{
this.joueur = joueur ?? throw new ArgumentNullException();
this.difficulte = difficulte;
this.taille = taille;
}
public Combat(Equipe joueur, Equipe ennemi, Difficulte difficulte)
{
this.joueur = joueur;
this.ennemi = ennemi;
this.difficulte = difficulte;
}
/// <summary>Crée une partie pour l'intelligence artificielle.</summary>
/// <param name="difficulte">Niveau de difficulté de la partie</param>
/// <param name="taille">Taille du plateau de la partie</param>
public Partie(Difficulte difficulte, Taille taille)
{
joueur = null;
this.difficulte = difficulte;
this.taille = taille;
}
/// <summary>
/// Genere une liste d'objet 'chiffre' à afficher
/// </summary>
/// <param name="maxWidth">Taille en hauteur</param>
/// <param name="maxHeight">taille en largeur</param>
/// <returns>la liste des chiffres</returns>
public IEnumerable <Chiffre> GenererListeChiffre(int maxWidth, int maxHeight)
{
_listeChiffre = new List <Chiffre>();
int nbChiffreMaxGenerer;
//pour définir le nombre de chiffre à générer
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
if (_nombreToursFait <= 4)
{
nbChiffreMaxGenerer = 6;
}
else if (_nombreToursFait <= 10)
{
nbChiffreMaxGenerer = 10;
}
else
{
nbChiffreMaxGenerer = 13;
}
}
else if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
if (_nombreToursFait <= 4)
{
nbChiffreMaxGenerer = 8;
}
else if (_nombreToursFait <= 10)
{
nbChiffreMaxGenerer = 14;
}
else
{
nbChiffreMaxGenerer = 18;
}
}
else
{
if (_nombreToursFait <= 4)
{
nbChiffreMaxGenerer = 12;
}
else if (_nombreToursFait <= 8)
{
nbChiffreMaxGenerer = 18;
}
else
{
nbChiffreMaxGenerer = 23;
}
}
int maxChoix = 0;
//génération des chiffres
for (var i = 0; i < nbChiffreMaxGenerer; i++)
{
var chiffre = _random.Next(2, 7);
var color = new Color();
switch (_random.Next(0, 3))
{
case 0: //noir
color = Color.FromArgb(255, 0, 0, 0);
break;
case 1: //bleu
color = Color.FromArgb(255, 0, 0, 180);
break;
case 2: //rouge
color = Color.FromArgb(255, 255, 0, 0);
break;
}
//animation si on est à plus de la moitié
var animation = MouvementEnum.Aucun;
if (i >= _nombreTours / 2)
{
var aleatoireAnim = _random.Next(0, 9);
switch (aleatoireAnim)
{
case 8:
animation = MouvementEnum.Agrandisssement;
break;
case 7:
animation = MouvementEnum.Agrandisssement;
break;
case 6:
animation = MouvementEnum.Rotation;
break;
case 5:
animation = MouvementEnum.TranslationVerticale;
break;
case 4:
animation = MouvementEnum.TranslationHorizontale;
break;
case 3:
animation = MouvementEnum.Rotation;
break;
}
}
var chiffreTmp = new Chiffre(i, chiffre, color, animation);
var testEmplacement = false;
var marginTopTmp = 0;
var marginLeftTmp = 0;
do
{
marginTopTmp = _random.Next(10, (animation.Equals(MouvementEnum.TranslationHorizontale) || animation.Equals(MouvementEnum.TranslationVerticale)) ? maxHeight - 115 : maxHeight - 10);
marginLeftTmp = _random.Next(10, (animation.Equals(MouvementEnum.TranslationHorizontale) || animation.Equals(MouvementEnum.TranslationVerticale)) ? maxWidth - 115 : maxWidth - 10);
if (_listeChiffre.Any(c => (c.MarginLeft - 40 > marginLeftTmp && c.MarginLeft + 40 < marginLeftTmp) &&
(c.MarginTop - 40 > marginTopTmp && c.MarginTop + 40 < marginTopTmp)))
{
testEmplacement = true;
}
} while (testEmplacement);
chiffreTmp.MarginTop = marginTopTmp;
chiffreTmp.MarginLeft = marginLeftTmp;
_listeChiffre.Add(chiffreTmp);
maxChoix = (i <= (_nombreTours / 2)) ? 3 : 4;
if (maxChoix == 4 && _listeChiffre.All(x => x.Mouvement == MouvementEnum.Aucun))
{
maxChoix = 3;
}
}
//génération de la question
var typeQuestion = TypeQuestionEnum.TypeChiffre;
switch (_random.Next(1, maxChoix))
{
case 1:
typeQuestion = TypeQuestionEnum.TypeChiffre;
break;
case 2:
typeQuestion = TypeQuestionEnum.TypeCouleur;
break;
case 3:
typeQuestion = TypeQuestionEnum.TypeMouvement;
break;
}
Question = ResourceLoader.GetForCurrentView().GetString("combien") + " ";
if (typeQuestion.Equals(TypeQuestionEnum.TypeChiffre))
{
Question += ResourceLoader.GetForCurrentView().GetString("de") + " ";
var liste = _listeChiffre.Select(x => x.Nombre).Distinct().ToList();
var empAl = _random.Next(0, liste.Count());
Question += liste[empAl].ToString();
_resultat = _listeChiffre.Count(x => x.Nombre == liste[empAl]);
}
else if (typeQuestion.Equals(TypeQuestionEnum.TypeCouleur))
{
Question += ResourceLoader.GetForCurrentView().GetString("de") + " ";
var liste = _listeChiffre.Select(x => x.Couleur).Distinct().ToList();
var empAl = _random.Next(0, liste.Count());
var col = liste[empAl];
_resultat = _listeChiffre.Count(x => x.Couleur.Equals(col));
if (col.Equals(Color.FromArgb(255, 0, 0, 0)))
{
Question += ResourceLoader.GetForCurrentView().GetString("Noir");
}
else if (col.Equals(Color.FromArgb(255, 0, 0, 180)))
{
Question += ResourceLoader.GetForCurrentView().GetString("Bleu");
}
else
{
Question += ResourceLoader.GetForCurrentView().GetString("Rouge");
}
}
else if (typeQuestion.Equals(TypeQuestionEnum.TypeMouvement))
{
var liste = _listeChiffre.Where(x => x.Mouvement != MouvementEnum.Aucun).Select(x => x.Mouvement).Distinct().ToList();
var empAl = _random.Next(0, liste.Count());
switch (liste[empAl])
{
case MouvementEnum.Rotation:
Question += ResourceLoader.GetForCurrentView().GetString("Tournent");
_resultat = _listeChiffre.Count(x => x.Mouvement == MouvementEnum.Rotation);
break;
case MouvementEnum.Agrandisssement:
Question += ResourceLoader.GetForCurrentView().GetString("ChangeTaille");
_resultat = _listeChiffre.Count(x => x.Mouvement == MouvementEnum.Agrandisssement);
break;
case MouvementEnum.TranslationVerticale:
Question += ResourceLoader.GetForCurrentView().GetString("Bougent");
_resultat = _listeChiffre.Count(x => x.Mouvement == MouvementEnum.TranslationHorizontale || x.Mouvement == MouvementEnum.TranslationVerticale);
break;
case MouvementEnum.TranslationHorizontale:
Question += ResourceLoader.GetForCurrentView().GetString("Bougent");
_resultat = _listeChiffre.Count(x => x.Mouvement == MouvementEnum.TranslationHorizontale || x.Mouvement == MouvementEnum.TranslationVerticale);
break;
}
}
Question += " ?";
return(_listeChiffre);
}
/// <summary>
/// Genère une opération à calculer en fonction de la difficulté et enregistre le résultat attendu
/// </summary>
/// <returns>l'opération à effectuer</returns>
public string GenererOperation()
{
//génération de l'opération
var operation = GetSigneOperation();
int premierNombre;
int deuxiemeNombre;
//génération du premier nombre
var valMaxA = 0;
if (operation.Equals(OperationEnum.Addition))
{
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
valMaxA = 13;
}
else if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
valMaxA = 31;
}
else
{
valMaxA = 101;
}
}
else if (operation.Equals(OperationEnum.Soustraction))
{
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
valMaxA = 10;
}
else if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
valMaxA = 31;
}
else
{
valMaxA = 101;
}
}
else if (operation.Equals(OperationEnum.Multiplication))
{
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
valMaxA = 11;
}
else if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
valMaxA = 12;
}
else
{
valMaxA = 14;
}
}
//cas particulier pour la division (on génère les deux chiffres directement)
if (operation.Equals(OperationEnum.Division))
{
valMaxA = 9;
deuxiemeNombre = _random.Next(valMaxA);
premierNombre = TableMultiplication[deuxiemeNombre, _random.Next(valMaxA)];
deuxiemeNombre += 2;
}
else
{
premierNombre = _random.Next(valMaxA);
//si ce n'est pas une division on doit générer le deuxième nombre
//pour une addition ou une multiplication, ca reste la même valeur que le premier
if (operation.Equals(OperationEnum.Addition) || operation.Equals(OperationEnum.Multiplication))
{
deuxiemeNombre = _random.Next(valMaxA);
}
//si c'est une soustraction, cas particulier
else
{
deuxiemeNombre = Difficulte.Equals(DifficulteEnum.FACILE) ? _random.Next(valMaxA, valMaxA + premierNombre) : _random.Next(valMaxA);
}
}
//calcul et retour de l'affichage
_compteurOperations++;
switch (operation)
{
case OperationEnum.Addition:
_resultatAttendu = premierNombre + deuxiemeNombre;
return(premierNombre + " + " + deuxiemeNombre + " = ");
case OperationEnum.Soustraction:
_resultatAttendu = deuxiemeNombre - premierNombre;
return(deuxiemeNombre + " - " + premierNombre + " = ");
case OperationEnum.Multiplication:
_resultatAttendu = premierNombre * deuxiemeNombre;
return(premierNombre + " x " + deuxiemeNombre + " = ");
case OperationEnum.Division:
_resultatAttendu = (premierNombre == 0 || deuxiemeNombre == 0) ? 0 : premierNombre / deuxiemeNombre;
return(premierNombre + " / " + deuxiemeNombre + " = ");
}
return(null);
}
/// <summary>
/// Affiche ou non la première ligne (en partant du haut) de la pyramide. (Seulement pour le niveau diffcile)
/// </summary>
/// <returns>true si difficile</returns>
public bool IsAffichePremiereLigne()
{
return(!Difficulte.Equals(DifficulteEnum.FACILE));
}
/// <summary>
/// Genere une suite de va et vient
/// </summary>
public void GenererJeu()
{
_listeInLeft = new List <int>();
_listeInUp = new List <int>();
_listeOut = new List <int>();
_nbVaVient = 0;
Resultat = 0;
int nbVaVientToDo;
if (Difficulte.Equals(DifficulteEnum.FACILE))
{
nbVaVientToDo = 5;
SetSpeed(4300);
}
else if (Difficulte.Equals(DifficulteEnum.MOYEN))
{
nbVaVientToDo = 7;
SetSpeed(_nombreToursFait <= 5?4300:3000);
}
else
{
nbVaVientToDo = 10;
SetSpeed(3000);
}
var nbPoint = _nbPointDepart;
for (var i = 0; i < nbVaVientToDo; i++)
{
int nbInL;
//personne entrant à gauche
do
{
nbInL = _random.Next(0, (_nbPointMax - nbPoint) > 8 ? 8 : _nbPointMax - nbPoint);
} while ((nbInL + nbPoint) > _nbPointMax);
nbPoint += nbInL;
_listeInLeft.Add(nbInL);
//si le niveau est difficile on ajoute une deuxième entrée
if (Difficulte.Equals(DifficulteEnum.DIFFICILE))
{
int nbInU;
do
{
nbInU = _random.Next(0, (_nbPointMax - nbPoint) > 8 ? 8 : _nbPointMax - nbPoint);
} while ((nbInU + nbPoint) > _nbPointMax);
nbPoint += nbInU;
_listeInUp.Add(nbInU);
}
else
{
_listeInUp.Add(0);
}
//personne sortante
var nbOut = _random.Next(0, nbPoint >= 8 ?8:nbPoint + 1);
nbPoint -= nbOut;
_listeOut.Add(nbOut);
}
Resultat = nbPoint;
}
