public int getNbrVictoire(string Nom, string Prenom)
{
int result = 0;
for (int i = 1; i < nbrParties; i++)
{
try
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(Partie));
XmlReader xmlReader = XmlReader.Create(((MainWindow)Owner).PathParties + i.ToString() + ".xml");
Partie partie = (Partie)xmlSerializer.Deserialize(xmlReader);
if (partie.Gagant == 1 && partie.Joueur1.Nom.Equals(Nom) && partie.Joueur1.Prenom.Equals(Prenom))
{
result++;
}
else if (partie.Gagant == 2 && partie.Joueur2.Nom.Equals(Nom) && partie.Joueur2.Prenom.Equals(Prenom))
{
result++;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Puissance4 - Erreur");
}
}
return(result);
}
public async Task <IActionResult> PutPartie(int id, Partie partie)
{
if (id != partie.Id)
{
return(BadRequest());
}
_context.Entry(partie).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PartieExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private void InitialiserListeDonnes(Partie partieSelectionnee)
{
_posDonne = new Dictionary <int, long>();
_lectureDonnes = new FileStream(Path.Combine(_cheminFichiers, partieSelectionnee.Identifiant + PATTERN_FICHIER_LISTE_DONNES), FileMode.Open, FileAccess.Read);
int octet = 0;
int numDonne = -1;
string libNumDonne = "1";
bool premierPV = true; // est vrai si le prochain ; est le premier
bool secondPV = false; // est vrai si le prochain ; est le seconde
bool lectureEntete = true; // est vrai si on est en train de lire l'entete (la premiere ligne)
long posDebutLigne = 0;
while ((octet = _lectureDonnes.ReadByte()) != -1)
{
switch (octet)
{
case LINE_FEED:
if (lectureEntete)
{
lectureEntete = false;
}
else
{
premierPV = true;
secondPV = false;
if (int.Parse(libNumDonne) != numDonne)
{
numDonne = int.Parse(libNumDonne);
_posDonne[numDonne] = posDebutLigne;
}
libNumDonne = string.Empty;
}
posDebutLigne = _lectureDonnes.Position;
break;
case ';':
if (premierPV)
{
secondPV = true;
premierPV = false;
}
else if (secondPV)
{
premierPV = false;
secondPV = false;
}
break;
default:
// On est en train de lire le numéro de donne
if (!lectureEntete && !premierPV && secondPV)
{
libNumDonne += (char)octet;
}
break;
}
}
_posDonne[numDonne + 1] = _lectureDonnes.Position;
}
public static void AfficherPlateau(Partie p)
{
StringBuilder ligneCartes = new StringBuilder();
StringBuilder cotesCartes = new StringBuilder();
StringBuilder valeursCartesJ1 = new StringBuilder();
StringBuilder valeursCartesJ2 = new StringBuilder();
for (int i = 0; i < p.DuelsJoues.Count; i++)
{
ligneCartes.Append("------ ");
cotesCartes.Append("| | ");
string valJ1 = string.Format("{0:00}", p.DuelsJoues[i].carteJoueur1.Valeur);
string valJ2 = string.Format("{0:00}", p.DuelsJoues[i].carteJoueur2.Valeur);
valeursCartesJ1.Append("| " + valJ1 + " | ");
valeursCartesJ2.Append("| " + valJ2 + " | ");
}
Console.WriteLine(ligneCartes);
Console.WriteLine(cotesCartes);
Console.WriteLine(valeursCartesJ1);
Console.WriteLine(cotesCartes);
Console.WriteLine(ligneCartes);
Console.WriteLine(ligneCartes);
Console.WriteLine(cotesCartes);
Console.WriteLine(valeursCartesJ2);
Console.WriteLine(cotesCartes);
Console.WriteLine(ligneCartes);
}
static public Partie CalculScorePartie(Partie partie)
{
Partie partieEnCours = partie;
int valeurCarteJoueur1 = 0;
int valeurCarteJoueur2 = 0;
int scoreJoueur1 = 0;
int scoreJoueur2 = 0;
for (int i = 0; i < partie.DuelsJoues.Count; i++)
{
valeurCarteJoueur1 = partie.DuelsJoues[i].carteJoueur1.Valeur;
valeurCarteJoueur2 = partie.DuelsJoues[i].carteJoueur2.Valeur;
if (valeurCarteJoueur1 > valeurCarteJoueur2)
{
scoreJoueur1++;
}
else if (valeurCarteJoueur2 > valeurCarteJoueur1)
{
scoreJoueur2++;
}
}
partieEnCours.Joueur1.Score = scoreJoueur1;
partieEnCours.Joueur2.Score = scoreJoueur2;
return(partieEnCours);
}
void Start()
{
conceptionTerminee = false;
string ipv4 = IPManager.GetIP(IPManager.ADDRESSFAM.IPv4); // On met l'adresse IP de l'appareil courant dans ipv4
if (ipv4 == Ip_serveur)
{
Partie.Initialize();
manager.StartServer(); // Connection Serveur
RegisterHandlers();
Debug.Log("Serveur connecté");
}
else
{
manager.StartClient(); // Connection Smartphone
Debug.Log("client");
myclient = new NetworkClient();
myclient.Connect(Ip_serveur, 7777);
JoueurStatic.Client = myclient;
canvas_serveur.SetActive(false);
canvas_client.SetActive(true);
}
playerInfos = new Dictionary <int, PlayerInfoData>();
}
static void Main()
{
IJeu jeu = new Partie();
Form vue = new FenetreDeJeu(jeu);
Application.Run(vue);
}
Demineur()
{
short choix;
m_Classement = new Classements();
do
{
choix = Menu.AfficherMenu();
switch (choix)
{
case 1:
m_Partie = new Partie(Menu.DemanderNom(), Menu.OptionDePartie());
if (m_Partie.CommencerPartie())
{ // Si partie retourne true, alors le joueur a batu son record.
m_Classement.MettreAJourJoueur(m_Partie.InfoDepartie());
m_Classement.SauvegardeDuClassement();
}
break;
case 2:
short visionnement = 0; //par défaut ne tri pas le classement
do
{
visionnement = (short)Menu.AfficherClassement(m_Classement.ToString(visionnement), visionnement);
}while (visionnement != 4);
break;
case 3:
break;
}
}while (choix != 3);
}
public void experienceA(int[,,] res, int a1, int a2, int mcts_time, int exp_size)
{
puissance4.PositionP4 pInitiale = new puissance4.PositionP4(true, 6, 7);
//JMCTS j1 = new JMCTS(a1, a1, mcts_time);
//JMCTS j0 = new JMCTS(a2, a2, mcts_time);
JMCTS j1 = new jmctsq6.JMCTSQ6(a1, a1, mcts_time);
JMCTS j0 = new jmctsq6.JMCTSQ6(a2, a2, mcts_time);
for (int i = 0; i < exp_size; i++)
{
Partie partie = new Partie(j1, j0, pInitiale);
partie.Commencer(false);
if (partie.r == Resultat.j1gagne)
{
res[a1 / step - 1, a2 / step - 1, 0] += 1;
}
else if (partie.r == Resultat.j0gagne)
{
res[a1 / step - 1, a2 / step - 1, 1] += 1;
}
else if (partie.r == Resultat.partieNulle)
{
res[a1 / step - 1, a2 / step - 1, 2] += 1;
}
}
}
public void Passif(Personnage p)
{
int pvVictime = p.PvActuel;
pvVictime -= (int)(Partie.personnageTour.Sorts[Partie.personnageTour.SortActif()].Dgt * (1 + ((float)Partie.personnageTour.DgtBonusActuel) / 100f - ((float)p.ResBonusActuel) / 100f));
if (pvVictime <= 0 && !Partie.MemeEquipe(this, p))
{
if (PaActuel < Pa)
{
PaActuel = Pa;
}
PmActuel += 6;
DgtBonusActuel += 100;
for (int i = 0; i < Partie.personnageTour.SortsCd.Length; i++)
{
if (Partie.personnageTour.SortsCd[i] > 0)
{
Partie.personnageTour.SortsCd[i] = 0;
Partie.personnageTour.affichageCdSort[i].text = "";
Partie.personnageTour.sortsIcone[i].GetComponent <SpriteRenderer>().color = Color.white;
}
}
}
}
private Tour CreerTour(List <Equipe> equipes, int numtour, int nbrEquipePremierTour)
{
Tour tour = new Tour(numTour);
int index = 0;
for (int i = 0; i < equipes.Count() / 2; i++)
{
if (nbrEquipePremierTour == 0)
{
break;
}
else
{
nbrEquipePremierTour -= 2;
}
PartieEquipe pe1 = new PartieEquipe(equipes[index]);
PartieEquipe pe2 = new PartieEquipe(equipes[index + 1]);
listBye.Remove(pe1.Equipe);
listBye.Remove(pe2.Equipe);
Partie partie = new Partie(pe1, pe2, ++numPartie);
index += 2;
tour.LstParties.Add(partie);
}
return(tour);
}
public async Task <ActionResult <Partie> > AddPartie(Partie partie)
{
_context.Partie.Add(partie);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPartie", new { id = partie.Id }, partie));
}
static void Main(string[] args)
{
partie = new Partie();
partie.Lancement();
Direction dir;
AffichageConsole.AffichageLaby(partie.joueur.Laby, partie.joueur);
while (true)
{
dir = ChangeCaseListener();
if (dir != Direction.AUTRE)
{
partie.DeplacementJoueur(dir);
Loot loot = partie.TryRamassageObjet(partie.joueur.Laby, partie.joueur.Position);
if (!Loot.IsNull(loot))
{
partie.joueur.SubirEffet(loot);
partie.joueur.Inventaire.Add(loot);
}
}
AffichageConsole.AffichageDeuxCartes(partie.joueur.Laby, partie.joueur);
}
}
void CommencerPartie()
{
// reset des chronomètres
tempsBlancs.Reset();
tempsNoirs.Reset();
tbrUndoMove.Enabled = false;
tbrUndoAllMoves.Enabled = false;
tbrRedoAllMoves.Enabled = false;
tbrRedoMove.Enabled = false;
// commencer une partie
jeu.CommencerPartie();
MoveHistory = new List <Snapshot>();
lvwMoveHistory.Items.Clear();
lblWhitesCaptures.Text = "0";
lblBlacksCaptures.Text = "0";
Partie p = (Partie)jeu;
MoveHistory.Add(new Snapshot
{
BlackScore = 0,
WhiteScore = 0,
HistoryItems = new List <string[]>(),
partie = new Partie(p)
});
}
private static void Main(string[] args)
{
//Préparation et démarrage du thread en charge d'écouter.
_thEcoute = new Thread(listen);
_thEcoute.Start();
partie = new Partie();
}
/// <summary>
/// Permet d'enregistrer le score de l'adversaire en base
/// </summary>
/// <param name="e"></param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
RetourAccueilBouton.IsEnabled = false;
//Récupération de la photo
DefiService defi = (DefiService)PhoneApplicationService.Current.State["defi"];
TaquinTermineImage.Source = new WriteableBitmap(Photo.DecodeImage(defi.ImageDefi));
//Récupération du score
Partie partieTermine = (Partie)PhoneApplicationService.Current.State["partie"];
ScoreTextBlock.Text = "Votre score : " + partieTermine.Score + " Pts";
Defi defiTermine = new Defi();
defiTermine.id_defi = defi.IdDefi;
defiTermine.score_adversaire_defi = partieTermine.Score;
defiTermine.resolu = true;
ServiceTaqnshareClient serviceTaqnshareClient = new ServiceTaqnshareClient();
serviceTaqnshareClient.ModifierDefiCompleted += DefiModifie;
serviceTaqnshareClient.ModifierDefiAsync(defiTermine, App.UtilisateurCourant);
base.OnNavigatedTo(e);
}
public UcGererPartie(Joueur joueur)
{
this.joueur = joueur;
this.partie = new Partie(this.joueur);
fenetrePartie = new FenetrePartie(this.partie);
this.subscribe(this.fenetrePartie);
}
public static void AfficherDuel(Partie p, Carte carteJoueur1, Carte carteJoueur2)
{
Console.WriteLine(p.Joueur1.Nom + " a joué : \n");
AffichageHelper.AfficherCarte(carteJoueur1);
Console.WriteLine(p.Joueur2.Nom + " a joué : \n");
AffichageHelper.AfficherCarte(carteJoueur2);
}
public StatsWindow(MainWindow newOwner)
{
InitializeComponent();
Owner = newOwner;
int nbrVictoires = 0;
int nbrPartiesGagne = 0;
int nbrFoisJoueeEnPremier = 0;
nbrParties = Directory.GetFiles(((MainWindow)Owner).PathParties, "*", SearchOption.AllDirectories).Length - 1;
for (int i = 1; i < nbrParties; i++)
{
try
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(Partie));
XmlReader xmlReader = XmlReader.Create(((MainWindow)Owner).PathParties + i.ToString() + ".xml");
Partie partie = (Partie)xmlSerializer.Deserialize(xmlReader);
//JoueurPlusVictoires
int res1 = getNbrVictoire(partie.Joueur1.Nom, partie.Joueur1.Prenom);
int res2 = getNbrVictoire(partie.Joueur2.Nom, partie.Joueur2.Prenom);
if (res1 > nbrVictoires)
{
nbrVictoires = res1;
JoueurPlusVictoires.Content = partie.Joueur1.Nom + " " + partie.Joueur2.Prenom + " " + res1.ToString();
}
else if (res2 > nbrVictoires)
{
nbrVictoires = res2;
JoueurPlusVictoires.Content = partie.Joueur2.Nom + " " + partie.Joueur2.Prenom + " " + res2.ToString();
}
//JoueurPlusPartiesJouees
int res3 = getNbrPartiesJouees(partie.Joueur1.Nom, partie.Joueur1.Prenom);
int res4 = getNbrPartiesJouees(partie.Joueur2.Nom, partie.Joueur2.Prenom);
if (res3 > nbrPartiesGagne)
{
nbrPartiesGagne = res3;
JoueurPlusParties.Content = partie.Joueur1.Nom + " " + partie.Joueur1.Prenom + " " + res3.ToString();
}
else if (res4 > nbrPartiesGagne)
{
nbrPartiesGagne = res4;
JoueurPlusParties.Content = partie.Joueur2.Nom + " " + partie.Joueur2.Prenom + " " + res4.ToString();
}
//CaseLaPlusJoueeEnPremier
int res5 = getNbrFoisJoueeEnPremier(partie.FirstLigne, partie.FirstColonne);
if (res5 > nbrFoisJoueeEnPremier)
{
nbrFoisJoueeEnPremier = res5;
CasePlusJouee.Content = string.Format("L: {0} C: {1} => {2}", partie.FirstLigne, partie.FirstColonne, res5);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Puissance4 - Erreur");
}
}
}
public void ModifierPartie(int id, int id_ami, int th, int score)
{
Partie partieEnCours = this.getPartieEnCours(id, id_ami);
if (partieEnCours != null)
{
if (partieEnCours.Manches.Last().s1 == -1)
{
partieEnCours.Manches.Last().s1 = score;
if (partieEnCours.Manches.Last().s1 > partieEnCours.Manches.Last().s2)
{
partieEnCours.s1 = partieEnCours.s1 + 1;
}
if (partieEnCours.Manches.Last().s1 < partieEnCours.Manches.Last().s2)
{
partieEnCours.s2 = partieEnCours.s2 + 1;
}
if (partieEnCours.s2 == 3 || partieEnCours.s1 == 3)
{
partieEnCours.player = -1;
}
}
else if (partieEnCours.Manches.Last().s2 == -1)
{
partieEnCours.Manches.Last().s2 = score;
if (partieEnCours.Manches.Last().s1 > partieEnCours.Manches.Last().s2)
{
partieEnCours.s1 = partieEnCours.s1 + 1;
}
if (partieEnCours.Manches.Last().s1 < partieEnCours.Manches.Last().s2)
{
partieEnCours.s2 = partieEnCours.s2 + 1;
}
if (partieEnCours.s2 == 3 || partieEnCours.s1 == 3)
{
partieEnCours.player = -1;
}
}
else
{
Theme theme = _themeService.getTheme(th);
if (id == partieEnCours.j1.id)
{
partieEnCours.Manches.Add(new Manche(theme, score, -1));
}
else
{
partieEnCours.Manches.Add(new Manche(theme, -1, score));
}
partieEnCours.player = id_ami;
}
context = new fmnContext();
context.parties.Update(partieEnCours);
context.SaveChanges();
}
}
public DebutPartieTest()
{
talonMock = new Mock <ITalon>();
piocheMock = new Mock <IPioche>();
tourMock = new Mock <ITour>();
partie = new Partie(talonMock.Object, piocheMock.Object, tourMock.Object);
}
public ViewPartieListPage(int state, List <ScorePartie> scoreParties, Partie partie)
{
InitializeComponent();
this.state = state;
this.partieStatPage = null;
this.scoreParties = scoreParties;
this.partie = partie;
}
public void Demarrer_une_nouvelle_partie()
{
Joueur joueurOuest = new Joueur("Ouest", JoueurType.Ordinateur);
Joueur joueurNord = new Joueur("Nord", JoueurType.Ordinateur);
Joueur joueurEst = new Joueur("Est", JoueurType.Ordinateur);
Joueur nicholas = new Joueur("Nicholas", JoueurType.Humain);
Partie partie = new Partie(1000, joueurOuest, joueurNord, joueurEst, nicholas);
}
/// <summary>
/// Demarrage de la lecture de la partie : on va lire le fichier partie pour faire un index des différentes positions du fichier partie
/// Idem pour le fichier donne
/// <remarks>La partie ne démarre bien que lorsque l'on lance démarrer</remarks>
/// </summary>
/// <param name="partieSelectionne"></param>
/// <returns>La liste des joueurs concernés par cette partie</returns>
public void DemarrageLecturePartie(Partie partieSelectionne)
{
InitialiserListeEvenements(partieSelectionne);
InitialiserListeDonnes(partieSelectionne);
_numEvtJeu = 0;
this.EvenementCourant = null;
}
public void Recommence()
{
_partieActuelle.JoueursOntChanges -= _partieActuelle_JoueursOntChanges;
_partieActuelle.CartesVisiblesOntChanges -= _partieActuelle_CartesVisiblesOntChanges;
_partieActuelle = new Partie();
_partieActuelle.JoueursOntChanges += _partieActuelle_JoueursOntChanges;
_partieActuelle.CartesVisiblesOntChanges += _partieActuelle_CartesVisiblesOntChanges;
}
public ActionResult DeleteConfirmed(int id)
{
Partie partie = db.Parties.Find(id);
db.Parties.Remove(partie);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ViewPartieListPage(int state)
{
InitializeComponent();
this.state = state;
this.partieStatPage = null;
this.scoreParties = null;
this.partie = null;
}
private void AnswerPost(Res response, Partie value)
{
SqlConnection connection = Models.Connexion.Get("Server=localhost;Database=foot;User ID=sa;Password=itu;");
Models.Departage dp = new Models.Departage(connection);
dp.DoIt(new Models.Partie(value));
response.error = false;
}
public void Demarrer_une_nouvelle_partie()
{
Joueur joueurOuest = new Joueur("Ouest", JoueurType.Ordinateur);
Joueur joueurNord = new Joueur("Nord", JoueurType.Ordinateur);
Joueur joueurEst = new Joueur("Est", JoueurType.Ordinateur);
Joueur nicholas = new Joueur("Nicholas", JoueurType.Humain);
Partie partie = new Partie(1000, joueurOuest, joueurNord, joueurEst, nicholas);
}
public IEnumerator PauseFin(float waitTime, int score, int dealer)
{
yield return(new WaitForSeconds(waitTime));
Partie.FinDePartie(score, dealer);
}
public JoueursTests()
{
talonMock = new Mock <ITalon>();
piocheMock = new Mock <IPioche>();
tourMock = new Mock <ITour>();
partie = new Partie(talonMock.Object, piocheMock.Object, tourMock.Object);
}
public CarteGraph(Partie p)
{
try
{
InitializeComponent();
DefinirImage();
partie = p;
idcourant = p.UniteCourante.Id;
MajPoint();
MajInfoUniteCourant();
AfficherCarte();
PlacerUnite();
PlacerUniteListe();
}
catch(PartieException exc){
if (exc.Type == "perdu" || exc.Type == "Fin")
{
MessageBox.Show(exc.Message);
this.Close();
}
}
}
public void Test_Partie_Attaque()
{
// Creation d'une partie DEMO ; avec deux joueur Gaulois / Viking
List<Joueur> l = new List<Joueur>();
l.Add(new Joueur(TypePeuple.GAULOIS, 1, new Coordonnee(0, 0)));
l.Add(new Joueur(TypePeuple.NAINS, 1, new Coordonnee(0, 1)));
TypeCase[][] grille = new TypeCase[1][];
grille[0] = new TypeCase[2];
grille[0][0] = TypeCase.MONTAGNE;
grille[0][1] = TypeCase.MONTAGNE;
IPartie p = new Partie("PartieTest", new CarteDemo(grille, null), l, 5);
try {
// p.Attaque(Direction.NORD);
} catch(PartieException e) {
Console.WriteLine(e.Message);
}
Assert.IsTrue(p.Joueurs[0].Peuple.Unites.Count == 1
|| p.Joueurs[0].Peuple.Unites.Count == 0);
}
