Beispiel #1
0
    override public bool canMoveOf(int _x, int _z, bool checkEchec)
    {
        bool done = false;

        if (Tour.rookMoveStyle(this, _x, _z))
        {
            done = base.canMoveOf(_x, _z, checkEchec);
        }
        if (!done && Fou.bishopMoveStyle(this, _x, _z))
        {
            done = base.canMoveOf(_x, _z, checkEchec);
        }
        return(done);
    }
Beispiel #2
0
        public Plateau()
        {
            echiquier = new Piece[8, 8];
            pN1       = new Pion(false);
            pN2       = new Pion(false);
            pN3       = new Pion(false);
            pN4       = new Pion(false);
            pN5       = new Pion(false);
            pN6       = new Pion(false);
            pN7       = new Pion(false);
            pN8       = new Pion(false);

            pB1 = new Pion(true);
            pB2 = new Pion(true);
            pB3 = new Pion(true);
            pB4 = new Pion(true);
            pB5 = new Pion(true);
            pB6 = new Pion(true);
            pB7 = new Pion(true);
            pB8 = new Pion(true);

            cavN1 = new Cavalier(false);
            cavN2 = new Cavalier(false);

            cavB1 = new Cavalier(true);
            cavB2 = new Cavalier(true);

            fouN1 = new Fou(false);
            fouN2 = new Fou(false);

            fouB1 = new Fou(true);
            fouB2 = new Fou(true);

            tourN1 = new Tour(false);
            tourN2 = new Tour(false);

            tourB1 = new Tour(true);
            tourB2 = new Tour(true);

            reineN = new Reine(false);
            reineB = new Reine(true);

            roiN         = new Roi(false);
            roiB         = new Roi(true);
            roiB.Couleur = true;

            initierPlateau(echiquier);
        }
    public void SetUpOpponent(string piece, int number)
    {
        Piece  p  = null;
        Sprite sp = null;

        switch (piece)
        {
        case "Pion":
        {
            p = new Pion();
            if (manager.playerColor == Tile.Colors.Blanc)
            {
                sp = PionNoir;
            }
            else
            {
                sp = PionBlanc;
            }
            break;
        }

        case "Tour":
        {
            p = new Tour();
            if (manager.playerColor == Tile.Colors.Blanc)
            {
                sp = TourNoir;
            }
            else
            {
                sp = TourBlanc;
            }
            break;
        }

        case "Cavalier":
        {
            p = new Cavalier();
            if (manager.playerColor == Tile.Colors.Blanc)
            {
                sp = CavalierNoir;
            }
            else
            {
                sp = CavalierBlanc;
            }
            break;
        }

        case "Fou":
        {
            p = new Fou();
            if (manager.playerColor == Tile.Colors.Blanc)
            {
                sp = FouNoir;
            }
            else
            {
                sp = FouBlanc;
            }
            break;
        }

        case "Dame":
        {
            p = new Dame();
            if (manager.playerColor == Tile.Colors.Blanc)
            {
                sp = DameNoir;
            }
            else
            {
                sp = DameBlanc;
            }
            break;
        }
        }

        switch (number)
        {
        case 1:
        {
            OppP1 = p;
            OppP1Sprite.sprite = sp;
            break;
        }

        case 2:
        {
            OppP2 = p;
            OppP2Sprite.sprite = sp;
            break;
        }

        case 3:
        {
            OppP3 = p;
            OppP3Sprite.sprite = sp;
            break;
        }
        }
    }
Beispiel #4
0
    public Echiquier(int[] tabVal)
    {
        tab = new Piece[8, 8];

        for (int i = 0; i < tabVal.Length; i++)
        {
            int y = i >> 3; //optimisation
            int x = (i & (8 - 1));
            //match all white pawns
            switch (tabVal[i])
            {
            case PP:
            case P:
                tab[x, y] = new Pion(false, x, y, this);
                mine.Add(tab[x, y]);
                break;

            case TG:
            case TD:
                tab[x, y] = new Tour(false, x, y, this);
                mine.Add(tab[x, y]);
                break;

            case CG:
            case CD:
                tab[x, y] = new Cavalier(false, x, y, this);
                mine.Add(tab[x, y]);
                break;

            case F:
                tab[x, y] = new Fou(false, x, y, this);
                mine.Add(tab[x, y]);
                break;

            case D:
                tab[x, y] = new Dame(false, x, y, this);
                mine.Add(tab[x, y]);
                break;

            case R:

                tab[x, y] = new Roi(false, x, y, this);
                mine.Add(tab[x, y]);
                break;

            case -PP:
            case -P:
                tab[x, y] = new PionNoir(true, x, y, this);
                yours.Add(tab[x, y]);
                break;

            case -TG:
            case -TD:
                tab[x, y] = new Tour(true, x, y, this);
                yours.Add(tab[x, y]);
                break;

            case -CG:
            case -CD:
                tab[x, y] = new Cavalier(true, x, y, this);
                yours.Add(tab[x, y]);
                break;

            case -F:
                tab[x, y] = new Fou(true, x, y, this);
                yours.Add(tab[x, y]);
                break;

            case -D:
                tab[x, y] = new Dame(true, x, y, this);
                yours.Add(tab[x, y]);
                break;

            case -R:

                tab[x, y] = new Roi(true, x, y, this);
                yours.Add(tab[x, y]);
                break;

            default:
                tab[x, y] = new Piece(0, true, x, y, this);
                break;
            }
        }
    }
Beispiel #5
0
 /// <summary>Évalue si le déplacement de la reine de la source à la destination est possible</summary>
 /// <param name="liSrc">Indice de la ligne source</param>
 /// <param name="liDest">Indice de la ligne de destination</param>
 /// <param name="colSrc">Indice de la colonne source</param>
 /// <param name="colDest">Indice de la colonne de destination</param>
 /// <returns>Retourne true si le déplacement de la reine est possible</returns>
 /// <remarks>Cette méthode ne tient pas compte des autres pièces possiblement présentes sur l'<see cref="Echiquier"></see></remarks>
 public override bool SiDeplacer(byte liSrc, byte liDest, byte colSrc, byte colDest) => Fou.SiDeplacerFou(liSrc, liDest, colSrc, colDest) || Tour.SiDeplacerTour(liSrc, liDest, colSrc, colDest);