Esempio n. 1
0
 /// <summary>
 /// Etat de la main à afficher
 /// </summary>
 public void ChangerCartes(Joueur expediteur, EtatMain etatDeLaMain)
 {
     _etatDeLaMain = etatDeLaMain;
     _joueur       = expediteur.Clone() as Joueur;
     ChangerTourDeJeu(_joueur.TourDeJeu);
     if (_etatDeLaMain != EtatMain.PasDeCartes)
     {
         _joueur.Carte1 = expediteur.Carte1;
         _joueur.Carte2 = expediteur.Carte2;
     }
     else
     {
         // Il faut impérativement enlever le style mis sur la grille sinon les cartes ne veulent pas s'effacer !!!!!
         grdCartes.Style           = null;
         lblDerniereAction.Content = string.Empty;
     }
     this.lblJoueur.Content = _joueur.Nom;
     MettreAJourImageCarteSelonEtat();
     try
     {
         this.lblTapis.Content = string.Format(OutilsTraduction.Traducteur.Traduire("TapisJoueur"), _joueur.TapisJoueur - _joueur.Mise);
         this.lblMise.Content  = string.Format(OutilsTraduction.Traducteur.Traduire("MiseJoueur"), _joueur.Mise);
     }
     catch (Exception ex)
     {
         logClient.Debug("Erreur lors de la traduction des informations du joueur : " + ex.Message);
         throw new Exception("Erreur de traduction : ChangerCartes", ex);
     }
     this.imgDonneur.Visibility     = _joueur.EstDealer() ? Visibility.Visible : Visibility.Hidden;
     this.imgPetiteBlind.Visibility = _joueur.EstPetiteBlind() ? Visibility.Visible : Visibility.Hidden;
     this.imgGrosseBlind.Visibility = _joueur.EstGrosseBlind() ? Visibility.Visible : Visibility.Hidden;
 }
Esempio n. 2
0
 private void LancerEvtChangementInfosJoueur(string nom, EtatMain etatDeLaMain, CartePoker carte1, CartePoker carte2, int?pot)
 {
     if (ChangementInfosJoueur != null)
     {
         ChangementInfosJoueur(_listeJoueurs[nom], etatDeLaMain, carte1, carte2, pot);
     }
 }
Esempio n. 3
0
 /// <summary>
 /// Réception d'un regard de carte
 /// </summary>
 /// <param name="joueurRegard">Le joueur regarde sa carte</param>
 /// <param name="regard">Début ou fin du regard</param>
 public void RecevoirRegard(Joueur expediteur, EtatMain etatDeLaMain)
 {
     if (Regard != null)
     {
         Regard(expediteur, etatDeLaMain);
     }
 }
Esempio n. 4
0
 /// <summary>
 /// Changement des infos d'un joueur
 /// </summary>
 /// <param name="joueurAChanger">Le joueur & ses infos</param>
 /// <param name="etatDeLaMain">L'etat de la main à afficher</param>
 /// <param name="carte1">Carte1 éventuellement</param>
 /// <param name="carte2">Carte2 éventuellement</param>
 /// <param name="pot">Le pot</param>
 public virtual void ChangerJoueur(Joueur joueurAChanger, EtatMain etatDeLaMain, CartePoker carte1, CartePoker carte2, int?pot)
 {
     if (joueurAChanger == _bot)
     {
         _bot.Carte1 = carte1;
         _bot.Carte2 = carte2;
     }
 }
Esempio n. 5
0
 /// <summary>
 /// Modification des propriétés d'un joueur
 /// </summary>
 /// <param name="joueurAChanger">Les nouvelles infos du joueur</param>
 /// <param name="etatDeLaMain">Le nouvel etat de sa main</param>
 public void ModifierCartesJoueur(Joueur joueurAChanger, EtatMain etatDeLaMain)
 {
     if (etatDeLaMain == EtatMain.PasDeCartes)
     {
         _listJoueurs[joueurAChanger].ChangerDerniereAction(string.Empty);
     }
     else
     {
         _listJoueurs[joueurAChanger].ChangerDerniereAction(RecupererLibelleDerniereAction(joueurAChanger));
     }
     _listJoueurs[joueurAChanger].ChangerCartes(joueurAChanger, etatDeLaMain);
 }
    // Start is called before the first frame update
    void Start()
    {
        controller = new Controller();

        currentStateMainD  = EtatMain.MAINOUVERTE;
        previousStateMainD = EtatMain.MAINOUVERTE;

        currentStateMainG  = EtatMain.MAINOUVERTE;
        previousStateMainG = EtatMain.MAINOUVERTE;

        currentPositionMainD  = paumeMainD.transform.position;
        previousPositionMainD = currentPositionMainD;

        currentPositionMainG  = paumeMainG.transform.position;
        previousPositionMainG = currentPositionMainG;
    }
Esempio n. 7
0
        /// <summary>
        /// Ajout d'un joueur (pas de changment
        /// </summary>
        /// <param name="joueurAAjouter">Le joueur à ajouter</param>
        public void AjouterJoueur(Joueur joueurAAjouter, EtatMain etatDeLaMain, int positionTable)
        {
            // Si nécessaire, on modifie toutes les positions des joueurs précédents
            foreach (JoueurControl jcJoueur in _listJoueurs.Values)
            {
                if (positionTable <= jcJoueur.PositionTable)
                {
                    jcJoueur.PositionTable++;
                }
            }

            JoueurControl cntr = new JoueurControl();

            cntr.PositionTable           = positionTable;
            _listJoueurs[joueurAAjouter] = cntr;
            cntr.CarteRegardee          += new JoueurControl.CarteRegardeeEventHandler(cntr_CarteRegardee);
            ModifierJoueur(joueurAAjouter);
            this.Children.Add(cntr);
        }
Esempio n. 8
0
 /// <summary>
 /// Modification des infos d'un joueur + les cartes + le pot
 /// </summary>
 /// <param name="joueurAChanger"></param>
 /// <param name="carte1"></param>
 /// <param name="carte2"></param>
 /// <param name="pot"></param>
 public void ChangerJoueur(Joueur joueurAChanger, EtatMain etatDeLaMain, CartePoker carte1, CartePoker carte2, int?pot)
 {
     logClient.Debug("Methode 'ChangerJoueur'");
     logClient.Debug("   Joueur   = " + joueurAChanger.Nom);
     logClient.Debug("   DerniereAction = " + joueurAChanger.DerniereAction.ToString());
     logClient.Debug("   Tapis = " + joueurAChanger.TapisJoueur.ToString());
     logClient.Debug("   JeterCartes = " + joueurAChanger.JeterCartes.ToString());
     logClient.Debug("   TourDeJeu = " + joueurAChanger.TourDeJeu.ToString());
     logClient.Debug("   EtatMain = " + etatDeLaMain);
     logClient.Debug("   Bouton = " + joueurAChanger.Bouton.ToString());
     logClient.Debug("   Carte1   = " + carte1);
     logClient.Debug("   Carte2   = " + carte2);
     if (pot.HasValue)
     {
         logClient.Debug("   Pot      = " + pot.Value.ToString());
     }
     if (ChangementInfosJoueur != null)
     {
         ChangementInfosJoueur(joueurAChanger, etatDeLaMain, carte1, carte2, pot);
     }
 }
Esempio n. 9
0
 /// <summary>
 /// Réception d'un regard : on sait quel est le joueur qui regarde ses cartes
 /// </summary>
 /// <param name="joueurRegard">Le joueur qui regarde</param>
 /// <param name="etatDeLaMain"></param>
 public virtual void RecevoirRegard(Joueur joueurRegard, EtatMain etatDeLaMain)
 {
 }
Esempio n. 10
0
    //après avoir déterminer les états des mains, on gère les sorts
    public void GestionSort()
    {
        if (currentStateMainD == EtatMain.ANNULATION)
        {
            if (currentSpellMainD != null)
            {
                currentSpellMainD.AnnulationSort();
            }
            return;
        }

        if (currentStateMainG == EtatMain.ANNULATION)
        {
            if (currentSpellMainG != null)
            {
                currentSpellMainG.AnnulationSort();
            }
            return;
        }

        //mains parallèles verticalement
        if (currentStateMainD == currentStateMainG && currentStateMainD == EtatMain.MAINSPARALLELESY)
        {
            if (mainParalleles && hadooken)
            {
                //instancier le sort dans la main droite
                currentSpellMainD = poolingManager.Incantation(Sort.HADOOKEN, paumeMainD, offsetPaumeD);
                currentSpellMainD.Incantation();
                starterMainD      = StarterSpell.SORTPAUME;
                currentStateMainD = EtatMain.SORTENCOURS;
            }
            else
            {
                if (mainParallelesGauche && hadooken)
                {
                    //instancier le sort dans la main gauche
                    currentSpellMainG = poolingManager.Incantation(Sort.HADOOKEN, paumeMainG, offsetPaumeG);
                    currentSpellMainG.Incantation();
                    starterMainG      = StarterSpell.SORTPAUME;
                    currentStateMainG = EtatMain.SORTENCOURS;
                }
            }
            mainParalleles       = false;
            mainParallelesGauche = false;
            return;
        }

        //Main Droite
        if (currentStateMainD == EtatMain.MAINOUVERTE && previousStateMainD == EtatMain.MAINFERMEE && bouleDeFeu)
        {
            //instancier le sort dans la main droite
            currentSpellMainD = poolingManager.Incantation(Sort.BOULEDEFEU, paumeMainD, offsetPaumeD);
            currentSpellMainD.Incantation();
            currentStateMainD = EtatMain.SORTENCOURS;
            starterMainD      = StarterSpell.SORTPAUME;
        }
        else
        {
            if (currentStateMainD == EtatMain.INDEXONLY && (previousStateMainD == EtatMain.MAINOUVERTE || previousStateMainD == EtatMain.MAINFERMEE) && bouleDeLaMort)
            {
                //instancier le sort dans la main droite
                currentSpellMainD = poolingManager.Incantation(Sort.BOULEDELAMORT, indexMainD, offsetIndexD);
                currentSpellMainD.Incantation();
                currentStateMainD = EtatMain.SORTENCOURS;
                starterMainD      = StarterSpell.SORTINDEX;
            }
            else
            {
                if (currentStateMainD == EtatMain.ALLBUTTHUMB && (previousStateMainD == EtatMain.MAINOUVERTE || previousStateMainD == EtatMain.MAINFERMEE) && laser)
                {
                    currentSpellMainD = poolingManager.Incantation(Sort.LASER, paumeMainD, offsetDosMainD);
                    currentSpellMainD.Incantation();
                    currentStateMainD = EtatMain.SORTENCOURS;
                    starterMainD      = StarterSpell.SORTDOSMAIN;
                }
            }
        }

        //Main Gauche
        if (currentStateMainG == EtatMain.MAINOUVERTE && previousStateMainG == EtatMain.MAINFERMEE && bouleDeFeu)
        {
            //instancier le sort dans la main gauche
            currentSpellMainG = poolingManager.Incantation(Sort.BOULEDEFEU, paumeMainG, offsetPaumeG);
            currentSpellMainG.Incantation();
            currentStateMainG = EtatMain.SORTENCOURS;
            starterMainG      = StarterSpell.SORTPAUME;
        }
        else
        {
            if (currentStateMainG == EtatMain.INDEXONLY && (previousStateMainG == EtatMain.MAINOUVERTE || previousStateMainG == EtatMain.MAINFERMEE) && bouleDeLaMort)
            {
                //instancier le sort dans la main gauche
                currentSpellMainG = poolingManager.Incantation(Sort.BOULEDELAMORT, indexMainG, offsetIndexG);
                currentSpellMainG.Incantation();
                currentStateMainG = EtatMain.SORTENCOURS;
                starterMainG      = StarterSpell.SORTINDEX;
            }
            else
            {
                if (currentStateMainG == EtatMain.ALLBUTTHUMB && (previousStateMainG == EtatMain.MAINOUVERTE || previousStateMainG == EtatMain.MAINFERMEE) && laser)
                {
                    currentSpellMainG = poolingManager.Incantation(Sort.LASER, paumeMainG, offsetDosMainG);
                    currentSpellMainG.Incantation();
                    currentStateMainG = EtatMain.SORTENCOURS;
                    starterMainG      = StarterSpell.SORTDOSMAIN;
                }
            }
        }
    }
Esempio n. 11
0
    //fonction pour déterminer l'état de la main
    public void DetermineEtatMain(bool droit)
    {
        //déterminer si les mains sont parallèles et ouvertes
        if ((mainParalleles || mainParallelesGauche) && currentStateMainD == EtatMain.MAINOUVERTE && currentStateMainG == EtatMain.MAINOUVERTE)
        {
            previousStateMainD = currentStateMainD;
            currentStateMainD  = EtatMain.MAINSPARALLELESY;

            previousStateMainG = currentStateMainG;
            currentStateMainG  = EtatMain.MAINSPARALLELESY;

            return;
        }

        if (droit)
        {
            if (currentStateMainD == EtatMain.LANCEMENT)
            {
                if (velociteMainD < seuilVitesseLancement)
                {
                    LancerSort(true);
                    previousStateMainD = currentStateMainD;
                    currentStateMainD  = EtatMain.ANNULATION;
                    return;
                }
                return;
            }

            //s'il n'y a aucun sort dans la main
            if (currentStateMainD != EtatMain.SORTENCOURS)
            {
                //récupération des distances entre les doigts et le centre de la paume
                List <float> listeDistance = new List <float>();
                listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, pouceMainD.position));
                listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, indexMainD.position));
                listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, majeurMainD.position));
                listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, annulaireMainD.position));
                listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, auriculaireMainD.position));

                if (listeDistance[0] > seuilPouce && listeDistance[1] > seuilIndex && listeDistance[2] > seuilMajeur && listeDistance[3] > seuilAnnulaire && listeDistance[4] > seuilAuriculaire)
                {
                    previousStateMainD = currentStateMainD;
                    currentStateMainD  = EtatMain.MAINOUVERTE;
                    return;
                }
                else
                {
                    if (listeDistance[0] < seuilPouce && listeDistance[1] > seuilIndex && listeDistance[2] < seuilMajeur && listeDistance[3] < seuilAnnulaire && listeDistance[4] < seuilAuriculaire)
                    {
                        //si la main est fermée suite à une annulation, l'état ne change pas
                        if (currentStateMainD == EtatMain.ANNULATION && (previousStateMainD == EtatMain.ANNULATION || previousStateMainD == EtatMain.SORTENCOURS))
                        {
                            return;
                        }

                        previousStateMainD = currentStateMainD;
                        currentStateMainD  = EtatMain.INDEXONLY;
                        return;
                    }
                    else
                    {
                        if (listeDistance[0] < seuilPouce && listeDistance[1] < seuilIndex && listeDistance[2] < seuilMajeur && listeDistance[3] < seuilAnnulaire && listeDistance[4] < seuilAuriculaire)
                        {
                            //si la main est fermée suite à une annulation, l'état ne change pas
                            if (currentStateMainD == EtatMain.ANNULATION && (previousStateMainD == EtatMain.ANNULATION || previousStateMainD == EtatMain.SORTENCOURS))
                            {
                                return;
                            }

                            previousStateMainD = currentStateMainD;
                            currentStateMainD  = EtatMain.MAINFERMEE;
                            return;
                        }
                        else
                        {
                            if (listeDistance[0] < seuilPouce && listeDistance[1] > seuilIndex && listeDistance[2] > seuilMajeur && listeDistance[3] > seuilAnnulaire && listeDistance[4] > seuilAuriculaire)
                            {
                                if (currentStateMainD == EtatMain.ANNULATION && (previousStateMainD == EtatMain.ANNULATION || previousStateMainD == EtatMain.SORTENCOURS))
                                {
                                    return;
                                }

                                previousStateMainD = currentStateMainD;
                                currentStateMainD  = EtatMain.ALLBUTTHUMB;
                                return;
                            }
                            else
                            {
                                //par défaut la main est ouverte
                                previousStateMainD = currentStateMainD;
                                currentStateMainD  = EtatMain.MAINOUVERTE;
                                return;
                            }
                        }
                    }
                }
            }
            else
            {
                //s'il y a un sort dans la main droite
                //récupération des distances entre les doigts et le centre de la paume
                List <float> listeDistance = new List <float>();
                listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, pouceMainD.position));
                listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, indexMainD.position));
                listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, majeurMainD.position));
                listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, annulaireMainD.position));
                listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, auriculaireMainD.position));

                if (listeDistance[0] < seuilPouce && listeDistance[1] < seuilIndex && listeDistance[2] < seuilMajeur && listeDistance[3] < seuilAnnulaire && listeDistance[4] < seuilAuriculaire)
                {
                    previousStateMainD = EtatMain.ANNULATION;
                    currentStateMainD  = EtatMain.ANNULATION;
                    return;
                }

                //si on dépasse une certaine vélocité, on passe en lancement
                if (velociteMainD > seuilVitesseLancement)
                {
                    previousStateMainD = currentStateMainD;
                    currentStateMainD  = EtatMain.LANCEMENT;
                }
            }
        }
        else
        {
            if (currentStateMainG == EtatMain.LANCEMENT)
            {
                if (velociteMainG < seuilVitesseDepart)
                {
                    LancerSort(false);
                    previousStateMainG = currentStateMainG;
                    currentStateMainG  = EtatMain.MAINOUVERTE;
                    return;
                }
                return;
            }

            //s'il n'y a aucun sort dans la main
            if (currentStateMainG != EtatMain.SORTENCOURS)
            {
                //récupération des distances entre les doigts et le centre de la paume
                List <float> listeDistance = new List <float>();
                listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, pouceMainG.position));
                listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, indexMainG.position));
                listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, majeurMainG.position));
                listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, annulaireMainG.position));
                listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, auriculaireMainG.position));

                //analyse des résultats
                if (listeDistance[0] > seuilPouce && listeDistance[1] > seuilIndex && listeDistance[2] > seuilMajeur && listeDistance[3] > seuilAnnulaire && listeDistance[4] > seuilAuriculaire)
                {
                    previousStateMainG = currentStateMainG;
                    currentStateMainG  = EtatMain.MAINOUVERTE;
                    return;
                }
                else
                {
                    if (listeDistance[0] < seuilPouce && listeDistance[1] > seuilIndex && listeDistance[2] < seuilMajeur && listeDistance[3] < seuilAnnulaire && listeDistance[4] < seuilAuriculaire)
                    {
                        if (currentStateMainG == EtatMain.ANNULATION && (previousStateMainG == EtatMain.ANNULATION || previousStateMainG == EtatMain.SORTENCOURS))
                        {
                            return;
                        }

                        previousStateMainG = currentStateMainG;
                        currentStateMainG  = EtatMain.INDEXONLY;
                        return;
                    }
                    else
                    {
                        if (listeDistance[0] < seuilPouce && listeDistance[1] < seuilIndex && listeDistance[2] < seuilMajeur && listeDistance[3] < seuilAnnulaire && listeDistance[4] < seuilAuriculaire)
                        {
                            if (currentStateMainG == EtatMain.ANNULATION && (previousStateMainG == EtatMain.ANNULATION || previousStateMainG == EtatMain.SORTENCOURS))
                            {
                                return;
                            }

                            previousStateMainG = currentStateMainG;
                            currentStateMainG  = EtatMain.MAINFERMEE;
                            return;
                        }
                        else
                        {
                            if (listeDistance[0] < seuilPouce && listeDistance[1] > seuilIndex && listeDistance[2] > seuilMajeur && listeDistance[3] > seuilAnnulaire && listeDistance[4] > seuilAuriculaire)
                            {
                                if (currentStateMainG == EtatMain.ANNULATION && (previousStateMainG == EtatMain.ANNULATION || previousStateMainG == EtatMain.SORTENCOURS))
                                {
                                    return;
                                }

                                previousStateMainG = currentStateMainG;
                                currentStateMainG  = EtatMain.ALLBUTTHUMB;
                                return;
                            }

                            else
                            {
                                //par défaut la main est ouverte
                                previousStateMainG = currentStateMainG;
                                currentStateMainG  = EtatMain.MAINOUVERTE;
                                return;
                            }
                        }
                    }
                }
            }
            else
            {
                //s'il y a un sort dans la main gauche
                //récupération des distances entre les doigts et le centre de la paume
                List <float> listeDistance = new List <float>();
                listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, pouceMainG.position));
                listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, indexMainG.position));
                listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, majeurMainG.position));
                listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, annulaireMainG.position));
                listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, auriculaireMainG.position));

                if (listeDistance[0] < seuilPouce && listeDistance[1] < seuilIndex && listeDistance[2] < seuilMajeur && listeDistance[3] < seuilAnnulaire && listeDistance[4] < seuilAuriculaire)
                {
                    previousStateMainG = EtatMain.ANNULATION;
                    currentStateMainG  = EtatMain.ANNULATION;
                    return;
                }

                //si on dépasse une certaine vélocité, on passe en lancement
                if (velociteMainG > seuilVitesseLancement)
                {
                    previousStateMainG = currentStateMainG;
                    currentStateMainG  = EtatMain.LANCEMENT;
                }
            }
        }
    }
Esempio n. 12
0
    // Update is called once per frame
    void Update()
    {
        previousPositionMainD = currentPositionMainD;
        currentPositionMainD  = paumeMainD.transform.position;

        previousPositionMainG = currentPositionMainG;
        currentPositionMainG  = paumeMainG.transform.position;

        var v = currentPositionMainD - previousPositionMainD;

        v            /= Time.deltaTime;
        velociteMainD = v.magnitude * 10;

        var v2 = currentPositionMainG - previousPositionMainG;

        v2           /= Time.deltaTime;
        velociteMainG = v2.magnitude * 10;

        Frame currentFrame = controller.Frame();

        nbMainsDetectees = currentFrame.Hands.Count;

        if (currentFrame.Hands.Count < 2)
        {
            if (currentFrame.Hands.Count == 0)
            {
                currentStateMainG  = EtatMain.PERDUE;
                previousStateMainG = EtatMain.PERDUE;
                if (currentSpellMainG != null)
                {
                    currentSpellMainG.AnnulationSort();
                }
                currentSpellMainG = null;

                currentStateMainD  = EtatMain.PERDUE;
                previousStateMainD = EtatMain.PERDUE;
                if (currentSpellMainD != null)
                {
                    currentSpellMainD.AnnulationSort();
                }
                currentSpellMainD = null;
            }
            else
            {
                if (currentFrame.Hands[0].IsRight)
                {
                    currentStateMainG  = EtatMain.PERDUE;
                    previousStateMainG = EtatMain.PERDUE;
                    if (currentSpellMainG != null)
                    {
                        currentSpellMainG.AnnulationSort();
                    }
                    currentSpellMainG = null;
                }
                else
                {
                    currentStateMainD  = EtatMain.PERDUE;
                    previousStateMainD = EtatMain.PERDUE;
                    if (currentSpellMainD != null)
                    {
                        currentSpellMainD.AnnulationSort();
                    }
                    currentSpellMainD = null;
                }
            }
        }

        //si on a au moins une main de détectée
        if (currentFrame.Hands.Count > 0)
        {
            foreach (var main in currentFrame.Hands)
            {
                if (main.IsRight)
                {
                    DetermineEtatMain(true);
                }
                else
                {
                    DetermineEtatMain(false);
                }
            }

            //gestion des sorts en fonction des états déterminés précédemment
            GestionSort();
        }
    }
Esempio n. 13
0
 /// <summary>
 /// Ajout d'un joueur (pas de changment
 /// </summary>
 /// <param name="joueurAAjouter">Le joueur à ajouter</param>
 public void AjouterJoueur(Joueur joueurAAjouter, EtatMain etatDeLaMain)
 {
     this.AjouterJoueur(joueurAAjouter, etatDeLaMain, this.Children.Count);
 }