Пример #1
0
        /// <summary>
        /// Retire une tuile de la main
        /// </summary>
        /// <param name="i">la position de la Tuile à retirer</param>
        /// <returns>Tuile retirée</returns>
        public Tuile retireTuile(int i)
        {
            Tuile t = new Tuile(m_oMain[i]);

            m_oMain[i] = new Tuile();
            return(t);
        }
Пример #2
0
        public int combiScore(Tuile t, int nb, bool cache)
        {
            int score = 0;

            //TODO:Ajout de la paire de son vent et de la paire de dragon
            switch (t.Couleur)
            {
            case 'f':
            case 's':
                score = 4;     //fleur/saison : 4pts
                break;

            case 'v':
            case 'd':
                if (nb == 3)
                {
                    score = 8;     //pung dragon/vent : 8pts
                }
                else if (nb == 4)
                {
                    score = 16;     //kong dragon/vent : 16pts
                }
                break;

            case 'c':
            case 'r':
            case 'b':
                if (t.Chiffre == 1 || t.Chiffre == 9)
                {
                    if (nb == 3)
                    {
                        score = 4;     // pung de 1/9 rond/bamboo/caractères : 8pts
                    }
                    else if (nb == 4)
                    {
                        score = 16;     // kong de 1/9 rond/bamboo/caractères : 16pts
                    }
                }
                else
                {
                    if (nb == 3)
                    {
                        score = 2;     // pung de autre rond/bamboo/caractères : 4pts
                    }
                    else if (nb == 4)
                    {
                        score = 8;     // kong de autre rond/bamboo/caractères : 8pts
                    }
                }
                break;

            default:
                break;
            }
            if (cache == true)
            {
                score *= 2; //double le score si combi cachée
            }
            return(score);
        }
Пример #3
0
        /// <summary>
        /// L'ordi defausse une tuile
        /// </summary>
        /// <param name="j">Numéro de joueur</param>
        private void ordiJoue(int j)
        {
            System.Random rand = new System.Random();
            int           i;
            int           iCompteur = 0; // on fait 28 fois le test pour trouver une tuile a defausser.Si on y arrive pas c'est qu'on a que des paires.
            Tuile         t;

            //Cherchons une tuile qu'on peut jeter
            do  //tuile aléatoire
            {
                i = rand.Next(14);
                if (iCompteur++ > 28 && m_oLesJoueurs[j].Main[i].Chiffre != 0)
                {
                    break;
                }
            }// Tant que la tuile selectionnée n'est pas vide, ou que j'en ai plusieurs (si je peux la prendre moi meme)
            while (m_oLesJoueurs[j].Main[i].Chiffre == 0 || m_oLesJoueurs[j].peutPrendre(m_oLesJoueurs[j].Main[i]));

            t = m_oLesJoueurs[j].retireTuile(i);
            m_oRepresentationJoueur[j].Affiche();//on rafraichi le jeu du joueur
            m_oTuileDefaussee = t;

            m_oVuejeu.MontrerTuileDefaussee(t.donneIcon());

            System.Console.Out.Write("Jette " + t.Nom + "\n");

            m_iCompteurTimer = 10;
            m_oTimerAttente.Start();
        }
Пример #4
0
        /// <summary> retourne true si le joueur a au moins 2 tuiles identiques à celle passée
        /// en paramètre
        /// </summary>
        public bool peutPrendre(Tuile t)
        {
            int  iNbTuileIdentique = 0;
            bool bResult           = false;

            if (t.Chiffre != 0)
            {
                for (int i = 0; i <= 13; i++)
                {
                    if (m_oMain[i].Chiffre != 0 && m_oMain[i].Chiffre == t.Chiffre && m_oMain[i].Couleur == t.Couleur)
                    {
                        iNbTuileIdentique++;
                    }
                    ///* si 2 tuiles sont semblables à celle proposée */
                    //if (m_oMain[i].Chiffre == t.Chiffre && m_oMain[i].Couleur == t.Couleur && m_oMain[i + 1].Chiffre == t.Chiffre && m_oMain[i + 1].Couleur == t.Couleur) {
                    //    return true; /* alors le joueur peut la prendre */
                    //}
                }
                if (iNbTuileIdentique > 1)
                {
                    bResult = true;
                }
                if (peutMahjong(t))
                {
                    bResult = true;
                }
            }
            return(bResult);
        }
Пример #5
0
        /// <summary> Le joueur a appuyé sur le bouton jouer/passer</summary>
        public void Jouer()
        {
            if (m_oTimerAttente.Enabled)
            {
                /* le timer tourne dc le joueur a demandé de passer au joueur suivant */
                m_oTimerAttente.Stop();
                m_oVuejeu.BtnJouer.Text = "Jouer";
                m_oVuejeu.MontrerTuileDefaussee(null);
                m_oVuejeu.BtnJouer.Enabled   = true;
                m_oVuejeu.BtnPrendre.Enabled = false;

                if (!OrdiFaitMahjong())
                {
                    bool bOrdiAPrit = false;
                    for (int i = 1; i < 4; i++)
                    {
                        if (!bOrdiAPrit)
                        {
                            bOrdiAPrit = OrdiPeutPrendre(i);
                        }
                    }
                    /* personne ne peut prendre la tuile */
                    if (!bOrdiAPrit)
                    {
                        m_oDefausse.add(m_oTuileDefaussee);

                        m_iAQuiDeJouer = (m_iAQuiDeJouer + 1) % 4; //joueur suivant
                        partie(true);
                    }
                }
            }
            else
            {
                /* le joueur joue */
                Tuile t = new Tuile();
                int   i = m_oLesJoueurs[0].TuileSelect;

                if (m_oLesJoueurs[0].TuileSelect != -1)
                {
                    /*il faut avoir séléctionner une tuile */
                    t = m_oLesJoueurs[0].retireTuile(i);
                    m_oRepresentationJoueur[0].PictureBoxMain[i].SetBounds(Constantes.X + 40 * i, Constantes.Y, 40, 50);
                    m_oRepresentationJoueur[0].Affiche();//on rafraichi le jeu du joueur
                    m_oLesJoueurs[0].TuileSelect = -1;
                    m_oTuileDefaussee            = t;
                    m_oVuejeu.MontrerTuileDefaussee(t.donneIcon());
                    m_oVuejeu.BtnJouer.Enabled    = false;
                    m_oVuejeu.BtnDeclarer.Enabled = false;
                    m_oVuejeu.BtnPrendre.Enabled  = false;

                    m_iCompteurTimer = 2;
                    m_oTimerAttente.Start();
                }
                else
                {
                    /* pas de tuile séléctionnée */
                }
            }
        }
Пример #6
0
 /// <summary>
 /// Ajout d'une tuile à la défausse
 /// </summary>
 /// <param name="t">La tuile defaussée</param>
 public void add(Tuile t)
 {
     tableau[t.Chiffre - 1, t.CouleurToInt()] += 1;
     if (m_oVue != null)
     {
         m_oVue.AfficherTuilesDefaussees();
     }
 }
Пример #7
0
        public int scorePartie(bool estGagnant)
        {
            int   score = 0, multi = 0;
            int   i = 0, index = 0;
            Tuile t = new Tuile();

            /* calcul des points des combinaisons */
            while (m_iIndexCombi[i] > 0)
            {
                t      = m_oCombinaison[index];
                score += combiScore(t, m_iIndexCombi[i], false);
                multi += combiMulti(t);
                index += m_iIndexCombi[i];
                i++;
            }

            /* calcul des points de la main */
            Tuile[] TuileMain = new Tuile[4];
            // si le joueur a des kong cachés
            if ((index = aKong(TuileMain)) > 0)
            {
                for (i = 0; i < index; i++)
                {
                    score += combiScore(TuileMain[i], 4, true);
                    multi += combiMulti(TuileMain[i]);
                }
            }
            // si le joueur a des pung cachés
            if ((index = aPung(TuileMain)) > 0)
            {
                for (i = 0; i < index; i++)
                {
                    score += combiScore(TuileMain[i], 3, true);
                    multi += combiMulti(TuileMain[i]);
                }
            }
            //on ajoute 2 point par paires (dragon et vent) cachées
            score += (aPaire() * 2);

            /* si le joueur a fait mahjong, +20pts*/
            if (estGagnant == true)
            {
                score += 20;
                /* trois doubles pour un jeu pur gagnant */
                if (aJeuPur())
                {
                    multi += 3;
                }
            }

            return((int)(score * System.Math.Pow(2, multi)));
        }
Пример #8
0
        /// <summary>Affiche le jeu du joueur</summary>
        private void AfficheJeu()
        {
            for (int i = 0; i < 14; i++)
            {
                if (m_oJoueur.Main[i].Chiffre != 0)
                {
                    switch (m_oJoueur.Numero)
                    {
                    case (0):
                        m_pbMain[i].Image = m_oJoueur.Main[i].donneIcon();
                        break;

                    case (1):
                        if (Options.GetOptions().MontreJeu)
                        {
                            m_pbMain[i].Image = RessourceManager.rotationIcon(m_oJoueur.Main[i].donneIcon(), -90);
                        }
                        else
                        {
                            m_pbMain[i].Image = Tuile.donneFond270();
                        }
                        break;

                    case (2):
                        if (Options.GetOptions().MontreJeu)
                        {
                            m_pbMain[i].Image = m_oJoueur.Main[i].donneIcon();
                        }
                        else
                        {
                            m_pbMain[i].Image = Tuile.donneFond();
                        }
                        break;

                    case (3):
                        if (Options.GetOptions().MontreJeu)
                        {
                            m_pbMain[i].Image = RessourceManager.rotationIcon(m_oJoueur.Main[i].donneIcon(), 90);
                        }
                        else
                        {
                            m_pbMain[i].Image = Tuile.donneFond90();
                        }
                        break;
                    }
                }
                else
                {
                    m_pbMain[i].Image = null;
                }
            }
        }
Пример #9
0
        /// <summary>
        /// Retire une Tuile de la main
        /// </summary>
        /// <param name="t">Tuile à retirée</param>
        public void retireTuile(Tuile t)
        {
            int i = 0;

            while (m_oMain[i].Chiffre != t.Chiffre || m_oMain[i].Couleur != t.Couleur && i < 14)
            {
                i++;
            }
            if (i < 14)
            {
                m_oMain[i] = new Tuile();
            }
        }
Пример #10
0
        public int combiMulti(Tuile t)
        {
            int multi = 0;

            if (t.Couleur == 'd')
            {
                // un double pour une combi de dragon
                multi += 1;
            }
            if ((t.Couleur == 'v' || t.Couleur == 'f' || t.Couleur == 's') && t.Chiffre == (m_iVent + 1))
            {
                multi += 1; // un double pour sa saison/fleur ou une combi de son vent
            }
            //TODO:Ajout du multi si la meme couleur
            return(multi);
        }
Пример #11
0
        /// <summary> Le joueur a appuyé sur le bouton Prendre </summary>
        public void Prendre()
        {
            Tuile[] comb = new Tuile[4];
            int     cpt  = 0;

            m_oTimerAttente.Stop();
            m_oVuejeu.BtnJouer.Text = "Jouer";
            m_oVuejeu.MontrerTuileDefaussee(null);
            m_oVuejeu.BtnJouer.Enabled   = true;
            m_oVuejeu.BtnPrendre.Enabled = false;

            System.Console.Out.Write("Vous prenez la tuile\n");
            if (m_oLesJoueurs[0].peutMahjong(m_oTuileDefaussee))
            {
                m_oLesJoueurs[0].ajouteTuile(m_oTuileDefaussee);
                m_oRepresentationJoueur[0].Affiche();//on raifraichi le jeu du joueur
                finPartie(0);
            }
            else
            {
                comb[cpt++] = new Tuile(m_oTuileDefaussee);
                for (int i = 0; i < 13; i++)
                {
                    if (m_oLesJoueurs[0].Main[i].Chiffre == m_oTuileDefaussee.Chiffre && m_oLesJoueurs[0].Main[i].Couleur == m_oTuileDefaussee.Couleur)
                    {
                        comb[cpt++] = new Tuile(m_oTuileDefaussee);
                        m_oLesJoueurs[0].Main[i] = new Tuile();
                    }
                }
                m_oLesJoueurs[0].ajouteCombi(comb, cpt);
                m_iAQuiDeJouer    = 0;
                m_oTuileDefaussee = null;
                m_oVuejeu.MontrerTuileDefaussee(null);
                if (cpt == 4)
                {
                    /* c t un kong don le joueur peut piocher */
                    partie(true);
                }
                else
                {
                    partie(false);
                }
            }
        }
Пример #12
0
        /// <summary>Initialise la pioche</summary>
        private void initPioche()
        {
            System.Random melange = new System.Random();
            Tuile         temp = new Tuile();
            int           x, y;

            m_oTuilesPioche          = new List <Tuile>();
            m_oTuilesPioche.Capacity = 144;
            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 9; j++)
                {
                    m_oTuilesPioche.Add(new Tuile(j + 1, 'c', (j + 1) + " caractère")); //chiffres
                    m_oTuilesPioche.Add(new Tuile(j + 1, 'b', (j + 1) + " bamboo"));    //bamboos
                    m_oTuilesPioche.Add(new Tuile(j + 1, 'r', (j + 1) + " rond"));      //ronds
                }
                for (int j = 0; j < 3; j++)
                {
                    m_oTuilesPioche.Add(new Tuile(j + 1, 'd', (j + 1) + " dragon")); //dragons
                }
                for (int j = 0; j < 4; j++)
                {
                    m_oTuilesPioche.Add(new Tuile(j + 1, 'v', (j + 1) + " Vent")); //vents
                }
                m_oTuilesPioche.Add(new Tuile(i + 1, 'f', (i + 1) + " fleur"));    //fleurs
                m_oTuilesPioche.Add(new Tuile(i + 1, 's', (i + 1) + " saison"));   //saisons
            }

            /* inverse 400 fois 2 tuiles aléatoires */
            for (int i = 0; i < 400; i++)
            {
                x    = melange.Next(144);
                y    = melange.Next(144);
                temp = m_oTuilesPioche[x];
                m_oTuilesPioche[x] = m_oTuilesPioche[y];
                m_oTuilesPioche[y] = temp;
            }
            m_iIndexPioche = 0;

            // on vide la défausse;
            m_oDefausse.init();

            m_oVuejeu.TuilePiochee();
        }
Пример #13
0
        /// <summary>
        /// Determine si l'ordi peut-il faire Mahjong?
        /// </summary>
        /// <returns>Resultat</returns>
        private bool OrdiFaitMahjong()
        {
            bool bResult = false;

            for (int i = 1; i < 4; i++)
            {
                if (m_oLesJoueurs[i].peutMahjong(m_oTuileDefaussee))
                {
                    System.Console.Out.Write("Le joueur " + i + " fait Mahjong\n");
                    m_oLesJoueurs[i].ajouteTuile(m_oTuileDefaussee);
                    m_iAQuiDeJouer    = i;
                    m_oTuileDefaussee = null;// new Tuile();
                    m_oVuejeu.MontrerTuileDefaussee(null);
                    finPartie(i);
                    bResult = true;
                }
            }
            return(bResult);
        }
Пример #14
0
        public bool peutMahjong(Tuile t)
        {
            bool result = false;
            int  i      = 0;

            if ((i = ajouteTuile(t)) >= 0)
            {
                if (aMahjong())
                {
                    result = true;
                }
                else
                {
                    result = false;
                }
                retireTuile(i);
            }
            return(result);
        }
Пример #15
0
        private int piocheTuiles(Joueur j, int nb)
        {
            int   t             = -1;
            Tuile oTuilePiochee = new Tuile();

            for (int i = 0; i < nb; i++)
            {
                oTuilePiochee = m_oTuilesPioche[m_iIndexPioche++];
                j.ajouteTuile(oTuilePiochee);
                m_oRepresentationJoueur[j.Numero].Tri();
                t = j.RecherchePositionTuile(oTuilePiochee);
                System.Console.Out.Write("Pioche du " + j.Main[t].Nom + "\n");
            }
            m_oRepresentationJoueur[j.Numero].Affiche();//on raifraichi le jeu du joueur

            m_oVuejeu.TuilePiochee();

            return(t);
        }
Пример #16
0
        /// <summary>
        /// Recherche la position dans la main de la Tuile
        /// </summary>
        /// <param name="t">Tuile</param>
        /// <returns>Position</returns>
        public int RecherchePositionTuile(Tuile t)
        {
            int i       = 0;
            int iReturn = 0;

            while (m_oMain[i].Couleur != 0 && i < 13)
            {
                i++;
            }

            for (int j = 0; j <= i; j++)
            {
                if ((m_oMain[j].Chiffre == t.Chiffre && m_oMain[j].Couleur == t.Couleur))
                {
                    iReturn = j;
                }
            }
            return(iReturn);
        }
Пример #17
0
        /// <summary>
        /// Determine si l'ordi peut-il prendre la tuile defaussée
        /// </summary>
        /// <param name="i">Numéro de joueur</param>
        /// <returns>Resultat</returns>
        private bool OrdiPeutPrendre(int i)
        {
            bool bResult = false;

            /* un ordi peut-il prendre la tuile? */
            if (m_oLesJoueurs[i].peutPrendre(m_oTuileDefaussee) && m_iAQuiDeJouer != i)
            {
                /* ce joueur peut prendre ? */
                Tuile[] comb = new Tuile[4];
                int     cpt  = 0;

                System.Console.Out.Write("Le joueur " + i + " prend la tuile\n");
                comb[cpt++] = new Tuile(m_oTuileDefaussee);

                for (int j = 0; j <= 13; j++)
                {
                    /*récuperation des tuiles */
                    if (m_oLesJoueurs[i].Main[j].Chiffre == m_oTuileDefaussee.Chiffre && m_oLesJoueurs[i].Main[j].Couleur == m_oTuileDefaussee.Couleur)
                    {
                        comb[cpt++] = new Tuile(m_oTuileDefaussee);
                        m_oLesJoueurs[i].Main[j] = new Tuile();
                    }
                }
                m_oLesJoueurs[i].ajouteCombi(comb, cpt); // ajout de la combi
                m_oRepresentationJoueur[i].Affiche();    //on rafraichi le jeu du joueur
                m_iAQuiDeJouer = i;

                if (cpt == 4)
                {
                    System.Console.Out.Write("Le joueur " + i + " déclare un kong\n");
                    partie(true);
                }
                else
                {
                    System.Console.Out.Write("Le joueur " + i + " déclare un pung\n");
                    partie(false);
                }
                bResult = true;
            }
            return(bResult);
        }
Пример #18
0
        public void DeclareKong(string sNom)
        {
            Tuile[] combi = new Tuile[4];
            int     cpt   = 0;

            for (int i = 0; i < 14; i++)
            {
                if (m_oMain[i].Nom == sNom)
                {
                    combi[cpt] = new Tuile(m_oMain[i]);
                    m_oMain[i] = new Tuile();
                    cpt++;
                }
                //if (String.CompareOrdinal(m_oMain[i].Nom, k.ToString()) == 0) {
                //    combi[cpt] = new Tuile(m_oMain[i]);
                //    m_oMain[i] = new Tuile();
                //    cpt++;
                //}
            }
            ajouteCombi(combi, 4);
        }
Пример #19
0
        /// <summary> Crée une nouveau jeu</summary>
        public void NouveauJeu()
        {
            int    temp;
            Random rand = new Random();

            m_oTimerAttente.Stop();

            /* Initialise */
            initPioche();
            m_iAQuiDeJouer = 3;// rand.Next(4);
            m_oLesJoueurs[m_iAQuiDeJouer].Vent           = Constantes.EST;
            m_oLesJoueurs[(m_iAQuiDeJouer + 1) % 4].Vent = Constantes.SUD;
            m_oLesJoueurs[(m_iAQuiDeJouer + 2) % 4].Vent = Constantes.OUEST;
            m_oLesJoueurs[(m_iAQuiDeJouer + 3) % 4].Vent = Constantes.NORD;
            initJoueurs();


            m_oTuileDefaussee = null;// new Tuile();

            /* initialisation des jeux */
            for (int i = 0; i < 4; i++)
            {
                do
                {
                    temp = m_oLesJoueurs[i].DeclareHonneur();
                    piocheTuiles(m_oLesJoueurs[i], temp);
                }while (temp > 0);
                m_oRepresentationJoueur[i].Affiche();
            }
            if (m_oLesJoueurs[0].TuileSelect >= 0)
            {
                m_oRepresentationJoueur[0].PictureBoxMain[m_oLesJoueurs[0].TuileSelect].SetBounds(Constantes.X + 40 * m_oLesJoueurs[0].TuileSelect, Constantes.Y, 40, 50);
                m_oLesJoueurs[0].TuileSelect = -1;
            }
            if (m_iAQuiDeJouer != 0)
            {
                m_oTimerAttente.Start();
                partie(false);
            }
        }
Пример #20
0
        /// <summary> Petit tri à bulle d'un main</summary>
        public void Tri()
        {
            Tuile temp = new Tuile();
            int   i    = 0;

            while (i < 13)
            {
                if (((m_oJoueur.Main[i].Couleur == 0) && (m_oJoueur.Main[i + 1].Couleur != 0)) || (m_oJoueur.Main[i].Couleur < m_oJoueur.Main[i + 1].Couleur) || (m_oJoueur.Main[i].Couleur == m_oJoueur.Main[i + 1].Couleur && m_oJoueur.Main[i].Chiffre < m_oJoueur.Main[i + 1].Chiffre))
                // ou couleur identique et chiffre supérieur
                {
                    // intervertion des tuiles
                    temp = m_oJoueur.Main[i];
                    m_oJoueur.Main[i]     = m_oJoueur.Main[i + 1];
                    m_oJoueur.Main[i + 1] = temp;
                    i = 0;
                }
                else
                {
                    i++;
                }
            }
        }
Пример #21
0
        /// <summary>
        /// Retourne si le jeu est pur
        /// </summary>
        /// <returns>Resultat</returns>
        private bool aJeuPur()
        {
            bool  estPur = false;
            char  typePur = ' ';
            int   i = 0, index = 0;
            Tuile t = new Tuile();

            //recherche dans les combinaisons
            while (m_iIndexCombi[i] > 0)
            {
                t = m_oCombinaison[index];
                if (t.Couleur == 'c' || t.Couleur == 'b' || t.Couleur == 'r')
                {
                    if (typePur != ' ' && typePur != t.Couleur)
                    {
                        estPur = false;         // alors ce n'est pas un jeu pur
                    }
                    typePur = t.Couleur;
                }
                index += m_iIndexCombi[i];
                i++;
            }

            //recherche dans la main
            for (int j = 0; i < 13; i++)
            {
                if ((m_oMain[j].Chiffre != 0) && (m_oMain[j].Couleur == 'c' || m_oMain[j].Couleur == 'b' || m_oMain[j].Couleur == 'r'))
                {
                    /* si le type pur a déja été défini et qu'il est different du type de la combi */
                    if (typePur != ' ' && typePur != m_oMain[j].Couleur)
                    {
                        estPur = false;         // alors ce n'est pas un jeu pur
                    }
                    typePur = m_oMain[j].Couleur;
                }
            }
            return(estPur);
        }
Пример #22
0
        /// <summary>
        /// Ajoute une Tuile dans la main
        /// </summary>
        /// <param name="t">Tuile</param>
        /// <returns>Position d'ajout (la derniere de la main)</returns>
        public int ajouteTuile(Tuile t)
        {
            int i = 0;

            while (m_oMain[i].Couleur != 0 && i < 13)
            {
                i++;
            }
            if (m_oMain[i].Couleur != 0 && i == 13)
            {
                //si le joueur a trop de tuile c pas bon
                i = -1;
            }
            else
            {
                m_oMain[i] = t;
                //i = 0;
                //while (m_oMain[i].Chiffre != t.Chiffre || m_oMain[i].Couleur != t.Couleur) {
                //    i++;
                //}
            }
            return(i);
        }
Пример #23
0
        /// <summary> Permet de faire déclarer à un joueur les fleurs et les saison qu'il a dans sa main
        /// Place ses fleurs et saison dans la zone de combinaison
        /// Renvoi le nombre de tuile déclarées
        /// </summary>
        public int DeclareHonneur()
        {
            Tuile[] combi    = new Tuile[4];
            int     index    = 0;
            int     nb_tuile = 0;

            /* initialise la nouvelle combinaison */
            for (int i = 0; i < 4; i++)
            {
                combi[i] = new Tuile();
            }

            //Pour chaque honneur que le joueur possède, ajoute ce dernier
            //aux combinaison et affiche la nouvelle combinaison
            while (aHonneur() >= 0)
            {
                index          = aHonneur();
                combi[0]       = m_oMain[index];
                m_oMain[index] = new Tuile();
                ajouteCombi(combi, 1);
                nb_tuile++;
            }
            return(nb_tuile);
        }
Пример #24
0
        /// <summary> Retourne le nombre de pung caché et leur nom</summary>
        public int aPung(Tuile[] oTuile)
        {
            int iNbPieceIdentique = 0, iNbPung = 0;

            for (int i = 0; i < 13; i++)
            {
                if ((m_oMain[i].Chiffre == m_oMain[i + 1].Chiffre) && (m_oMain[i].Chiffre != 0) && (m_oMain[i].Couleur == m_oMain[i + 1].Couleur) && (m_oMain[i].Couleur != 0))
                {
                    iNbPieceIdentique++;
                }
                else
                {
                    if (iNbPieceIdentique == 2)
                    {
                        //la combi précédente était un pung
                        oTuile[iNbPung] = new Tuile(m_oMain[i]);
                        iNbPung++;
                    }
                    iNbPieceIdentique = 0;
                }
            }

            return(iNbPung);
        }
Пример #25
0
        /// <summary> Retourne le nombre de kong caché et leurs Tuiles</summary>
        public int aKong(Tuile[] oTuile)
        {
            int iNbPieceIdentique = 0, iNbKong = 0;

            for (int i = 0; i < 13; i++)
            {
                if ((m_oMain[i].Chiffre == m_oMain[i + 1].Chiffre) && (m_oMain[i].Chiffre != 0) && (m_oMain[i].Couleur == m_oMain[i + 1].Couleur) && (m_oMain[i].Couleur != 0))
                {
                    iNbPieceIdentique++;
                    if (iNbPieceIdentique == 3)
                    {
                        oTuile[iNbKong] = new Tuile(m_oMain[i]);
                        iNbKong++;
                        iNbPieceIdentique = 0;
                    }
                }
                else
                {
                    iNbPieceIdentique = 0;
                }
            }

            return(iNbKong);
        }
Пример #26
0
        public frmPrinc()
        {
            InitializeComponent();
            try {
                m_oMahjong = new Mahjong(this, this.timer1);
                Defausse.getDefausse().Vue = this;

                this.BackColor            = System.Drawing.Color.FromArgb(20, 140, 20);
                this.lblDiscard.BackColor = System.Drawing.Color.FromArgb(20, 140, 20);
                this.lblJoueur1.BackColor = System.Drawing.Color.FromArgb(20, 140, 20);
                this.lblJoueur2.BackColor = System.Drawing.Color.FromArgb(20, 140, 20);
                this.lblJoueur3.BackColor = System.Drawing.Color.FromArgb(20, 140, 20);
                this.lblJoueur4.BackColor = System.Drawing.Color.FromArgb(20, 140, 20);
                this.lblReste.BackColor   = System.Drawing.Color.FromArgb(20, 140, 20);

                AffichageDesNomsJoueurs();


                for (int i = 0; i < 14; i++)
                {
                    System.Windows.Forms.PictureBox pbJoueur1;
                    System.Windows.Forms.PictureBox pbJoueur2;
                    System.Windows.Forms.PictureBox pbJoueur3;
                    System.Windows.Forms.PictureBox pbJoueur4;

                    pbJoueur1       = new System.Windows.Forms.PictureBox();
                    pbJoueur1.Image = Tuile.donneFond();
                    m_oMahjong.RepresentationJoueur[0].PictureBoxMain[i] = pbJoueur1;
                    pbJoueur2       = new System.Windows.Forms.PictureBox();
                    pbJoueur2.Image = Tuile.donneFond270();
                    m_oMahjong.RepresentationJoueur[1].PictureBoxMain[i] = pbJoueur2;
                    pbJoueur3       = new System.Windows.Forms.PictureBox();
                    pbJoueur3.Image = Tuile.donneFond();
                    m_oMahjong.RepresentationJoueur[2].PictureBoxMain[i] = pbJoueur3;
                    pbJoueur4       = new System.Windows.Forms.PictureBox();
                    pbJoueur4.Image = Tuile.donneFond90();
                    m_oMahjong.RepresentationJoueur[3].PictureBoxMain[i] = pbJoueur4;

                    m_oMahjong.RepresentationJoueur[0].PictureBoxMain[i].SetBounds(Constantes.X + (i * 40), Constantes.Y, 40, 50);
                    m_oMahjong.RepresentationJoueur[1].PictureBoxMain[i].SetBounds(Constantes.X + 700, Constantes.Y - 550 + (i * 40), 50, 40);
                    m_oMahjong.RepresentationJoueur[2].PictureBoxMain[i].SetBounds(Constantes.X + (i * 40), Constantes.Y - 610, 40, 50);
                    m_oMahjong.RepresentationJoueur[3].PictureBoxMain[i].SetBounds(Constantes.X - 150, Constantes.Y - 550 + (i * 40), 50, 40);

                    m_oMahjong.RepresentationJoueur[0].PictureBoxMain[i].MouseClick += new System.Windows.Forms.MouseEventHandler(this.lblMouseClick);
                    this.Controls.Add(m_oMahjong.RepresentationJoueur[0].PictureBoxMain[i]);
                    this.Controls.Add(m_oMahjong.RepresentationJoueur[1].PictureBoxMain[i]);
                    this.Controls.Add(m_oMahjong.RepresentationJoueur[2].PictureBoxMain[i]);
                    this.Controls.Add(m_oMahjong.RepresentationJoueur[3].PictureBoxMain[i]);
                    pbJoueur1 = null;
                    pbJoueur2 = null;
                    pbJoueur3 = null;
                    pbJoueur4 = null;
                }

                for (int i = 0; i < 14; i++)
                {
                    m_oMahjong.RepresentationJoueur[0].PictureBoxCombi[i] = new System.Windows.Forms.PictureBox();
                    m_oMahjong.RepresentationJoueur[1].PictureBoxCombi[i] = new System.Windows.Forms.PictureBox();
                    m_oMahjong.RepresentationJoueur[2].PictureBoxCombi[i] = new System.Windows.Forms.PictureBox();
                    m_oMahjong.RepresentationJoueur[3].PictureBoxCombi[i] = new System.Windows.Forms.PictureBox();

                    m_oMahjong.RepresentationJoueur[0].PictureBoxCombi[i].SetBounds(Constantes.X + (i * 40), Constantes.Y - 55, 40, 50);
                    m_oMahjong.RepresentationJoueur[1].PictureBoxCombi[i].SetBounds(Constantes.X + 700 - 55, Constantes.Y - 550 + (i * 40), 50, 40);
                    m_oMahjong.RepresentationJoueur[2].PictureBoxCombi[i].SetBounds(Constantes.X + (i * 40), Constantes.Y - 610 + 55, 40, 50);
                    m_oMahjong.RepresentationJoueur[3].PictureBoxCombi[i].SetBounds(Constantes.X - 150 + 55, Constantes.Y - 550 + (i * 40), 50, 40);

                    this.Controls.Add(m_oMahjong.RepresentationJoueur[0].PictureBoxCombi[i]);
                    this.Controls.Add(m_oMahjong.RepresentationJoueur[1].PictureBoxCombi[i]);
                    this.Controls.Add(m_oMahjong.RepresentationJoueur[2].PictureBoxCombi[i]);
                    this.Controls.Add(m_oMahjong.RepresentationJoueur[3].PictureBoxCombi[i]);
                }
                for (int i = 14; i < 24; i++)
                {
                    m_oMahjong.RepresentationJoueur[0].PictureBoxCombi[i] = new System.Windows.Forms.PictureBox();
                    m_oMahjong.RepresentationJoueur[1].PictureBoxCombi[i] = new System.Windows.Forms.PictureBox();
                    m_oMahjong.RepresentationJoueur[2].PictureBoxCombi[i] = new System.Windows.Forms.PictureBox();
                    m_oMahjong.RepresentationJoueur[3].PictureBoxCombi[i] = new System.Windows.Forms.PictureBox();

                    m_oMahjong.RepresentationJoueur[0].PictureBoxCombi[i].SetBounds(Constantes.X + ((i - 14) * 40), Constantes.Y - 108, 40, 50);
                    m_oMahjong.RepresentationJoueur[1].PictureBoxCombi[i].SetBounds(Constantes.X - 150 + 108, Constantes.Y - 550 + ((i - 14) * 40), 50, 40);
                    m_oMahjong.RepresentationJoueur[2].PictureBoxCombi[i].SetBounds(Constantes.X + ((i - 14) * 40), Constantes.Y - 630 + 108, 40, 50);
                    m_oMahjong.RepresentationJoueur[3].PictureBoxCombi[i].SetBounds(Constantes.X + 700 - 108, Constantes.Y - 550 + ((i - 14) * 40), 50, 40);

                    this.Controls.Add(m_oMahjong.RepresentationJoueur[0].PictureBoxCombi[i]);
                    this.Controls.Add(m_oMahjong.RepresentationJoueur[1].PictureBoxCombi[i]);
                    this.Controls.Add(m_oMahjong.RepresentationJoueur[2].PictureBoxCombi[i]);
                    this.Controls.Add(m_oMahjong.RepresentationJoueur[3].PictureBoxCombi[i]);
                }

                /* initialisation des label pour le Vent des joueurs */
                m_oMahjong.RepresentationJoueur[0].PictureBoxVent.SetBounds(750, 650, 40, 50);
                m_oMahjong.RepresentationJoueur[1].PictureBoxVent.SetBounds(880, 50, 50, 40);
                m_oMahjong.RepresentationJoueur[2].PictureBoxVent.SetBounds(130, 40, 40, 50);
                m_oMahjong.RepresentationJoueur[3].PictureBoxVent.SetBounds(30, 50, 50, 40);


                this.Controls.Add(m_oMahjong.RepresentationJoueur[0].PictureBoxVent);
                this.Controls.Add(m_oMahjong.RepresentationJoueur[1].PictureBoxVent);
                this.Controls.Add(m_oMahjong.RepresentationJoueur[2].PictureBoxVent);
                this.Controls.Add(m_oMahjong.RepresentationJoueur[3].PictureBoxVent);
            }
            catch (Exception ex) {
                System.Windows.Forms.MessageBox.Show(ex.Message + "\n\n" + ex.StackTrace, "Erreur...", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
Пример #27
0
        //public void affiche(Tuile[] main) {
        //for(int i=0; i<14; i++){
        //    if(main[i].Chiffre == 0 || main[i].Couleur == 0){
        //        labelDiscard[i].setText("");
        //    }
        //    else{
        //        if(Main.montreDiscard){
        //            labelDiscard[i].setText(""+tableau[main[i].chiffre-1][couleurToInt(main[i].couleur)]);
        //        }
        //        else{
        //            labelDiscard[i].setText("");
        //        }
        //    }
        //}
        //}

        /// <summary>
        /// Retourne le nombre de tuile jetée
        /// </summary>
        /// <param name="t">Tuile</param>
        /// <returns>Resultat</returns>
        public int nbJet(Tuile t)
        {
            return(tableau[t.Chiffre - 1, t.CouleurToInt()]);
        }
Пример #28
0
 /// <summary>
 /// Constructeur à partir d'une tuile existante
 /// </summary>
 /// <param name="t"></param>
 public Tuile(Tuile t)
 {
     m_iChiffre = t.Chiffre;
     m_cCouleur = t.Couleur;
     m_sNom     = t.Nom;
 }
Пример #29
0
 /// <summary>
 /// Retourne le nombre de tuile jetée
 /// </summary>
 /// <param name="t">Tuile</param>
 /// <returns>Resultat</returns>
 public int nbJet(int iChiffre, char cCouleur)
 {
     return(tableau[iChiffre - 1, Tuile.CouleurToInt(cCouleur)]);
 }