Esempio n. 1
0
        public void MaakZet(int x, int y)
        {
            stukje spelernietaanzet = this.SpelerNietAanZet;

            this[x, y] = SpelerAanZet;
            int tel;

            for (int r = 0; r < 8; r++)
            {
                tel = 0;
                for (int i = 1; richtingen[r](x, y, i); i++)
                {
                    stukje veld = this[riXen[r](x, y, i), riYen[r](x, y, i)];
                    if (veld == spelernietaanzet)
                    {
                        tel++;
                    }
                    else
                    {
                        if (veld == stukje.leeg)
                        {
                            tel = 0;
                        }
                        for (; tel > 0; tel--)
                        {
                            this[riXen[r](x, y, tel), riYen[r](x, y, tel)] = SpelerAanZet;
                        }
                        break;
                    }
                }
            }
            this.SpelerAanZet = spelernietaanzet;
        }
Esempio n. 2
0
        // Constructor
        public ReversiBord(int breedte, int hoogte)
        {
            // Bouw het bord op
            this.Breedte = breedte;
            this.Hoogte  = hoogte;
            this.bord    = new stukje[breedte, hoogte];

            // Zet de startsituatie op: vier stukken in het midden
            int midx = (breedte / 2) - 1;
            int midy = (hoogte / 2) - 1;

            bord[midx, midy]         = stukje.blauw;
            bord[midx, midy + 1]     = stukje.rood;
            bord[midx + 1, midy]     = stukje.rood;
            bord[midx + 1, midy + 1] = stukje.blauw;

            // Spelstatus: blauw begint
            this.SpelerAanZet      = stukje.blauw;
            this.beurtOvergeslagen = false;
            this.spelActief        = true;

            // Bouw richtingenarray voor zettencontrole

            /* Door de array richtingen kunnen we gemakkelijk checken in alle 8 richtingen of een zet geldig is.
             * Een richting is een combinatie van een of twee condities, die samen bepalen wanneer de rand van het bord is bereikt in ControleerZet.
             * De richtingen worden via de volgende tabel opgebouwd
             *
             *      | x>=0 |    | x < B
             * y>=0 |  LB  | B  | RB
             *      |  L   |    | R
             * y<H  |  LO  | O  | RO
             *
             * Waarbij B = this.Breedte en H = this.Hoogte
             */
            richtingen = new rico[8]
            {
                (x, y, i) => (x - i >= 0 && y - i >= 0),                    // LB
                (x, y, i) => (y - i >= 0),                                  // B
                (x, y, i) => (x + i < this.Breedte && y - i >= 0),          // RB
                (x, y, i) => (x - i >= 0),                                  // L
                (x, y, i) => (x + i < this.Breedte),                        // R
                (x, y, i) => (x - i >= 0 && y + i < this.Hoogte),           // LO
                (x, y, i) => (y + i < this.Hoogte),                         // O
                (x, y, i) => (x + i < this.Breedte && y + i < this.Hoogte)  // RO
            };
        }
Esempio n. 3
0
        // Constructor
        public ReversiBord(int breedte, int hoogte)
        {
            // Bouw het bord op
            this.Breedte = breedte;
            this.Hoogte = hoogte;
            this.bord = new stukje[breedte, hoogte];

            // Zet de startsituatie op: vier stukken in het midden
            int midx = (breedte / 2) - 1;
            int midy = (hoogte / 2) - 1;
            bord[midx, midy] = stukje.blauw;
            bord[midx, midy + 1] = stukje.rood;
            bord[midx + 1, midy] = stukje.rood;
            bord[midx + 1, midy + 1] = stukje.blauw;

            // Spelstatus: blauw begint
            this.SpelerAanZet = stukje.blauw;
            this.beurtOvergeslagen = false;
            this.spelActief = true;

            // Bouw richtingenarray voor zettencontrole
            /* Door de array richtingen kunnen we gemakkelijk checken in alle 8 richtingen of een zet geldig is.
             * Een richting is een combinatie van een of twee condities, die samen bepalen wanneer de rand van het bord is bereikt in ControleerZet.
             * De richtingen worden via de volgende tabel opgebouwd
             *
             *      | x>=0 |    | x < B
             * y>=0 |  LB  | B  | RB
             *      |  L   |    | R
             * y<H  |  LO  | O  | RO
             *
             * Waarbij B = this.Breedte en H = this.Hoogte
             */
            richtingen = new rico[8]
            {
                (x,y,i) => (x-i >= 0 && y-i >= 0),                      // LB
                (x,y,i) => (y-i >= 0),                                  // B
                (x,y,i) => (x+i < this.Breedte && y-i >= 0),            // RB
                (x,y,i) => (x-i >= 0),                                  // L
                (x,y,i) => (x+i < this.Breedte),                        // R
                (x,y,i) => (x-i >= 0 && y+i < this.Hoogte),             // LO
                (x,y,i) => (y+i < this.Hoogte),                         // O
                (x,y,i) => (x+i < this.Breedte && y+i < this.Hoogte)    // RO
            };
        }
Esempio n. 4
0
        // Zetten checken maken en speleinde
        public int ControleerZet(int x, int y, bool snel = true)
        {
            int aantal = 0;

            if (this[x, y] != stukje.leeg)
            {
                return(0);                           // Veld moet leeg zijn
            }
            int    testX            = 0;
            int    testY            = 0;
            stukje spelernietaanzet = this.SpelerNietAanZet;

            int tel;

            for (int r = 0; r < 8; r++)
            {
                tel = 0;
                for (int i = 1; richtingen[r](x, y, i); i++)
                {
                    testX = riXen[r](x, y, i);
                    testY = riYen[r](x, y, i);
                    stukje veld = this[testX, testY];
                    if (veld == spelernietaanzet)
                    {
                        tel++;
                    }
                    else
                    {
                        if (veld == stukje.leeg)
                        {
                            tel = 0;                            // moet wel een eigen stuk zitten he
                        }
                        aantal += tel;
                        break;
                    }
                }
                if (snel && aantal > 0)
                {
                    return(aantal);
                }
            }
            return(aantal);
        }
Esempio n. 5
0
 public void MaakZet(int x, int y)
 {
     stukje spelernietaanzet = this.SpelerNietAanZet;
     this[x, y] = SpelerAanZet;
     int tel;
     for (int r = 0; r < 8; r++)
     {
         tel = 0;
         for (int i = 1; richtingen[r](x, y, i); i++)
         {
             stukje veld = this[riXen[r](x, y, i), riYen[r](x, y, i)];
             if (veld == spelernietaanzet)
                 tel++;
             else
             {
                 if (veld == stukje.leeg) tel = 0;
                 for (; tel > 0; tel--)
                 {
                     this[riXen[r](x, y, tel), riYen[r](x, y, tel)] = SpelerAanZet;
                 }
                 break;
             }
         }
     }
     this.SpelerAanZet = spelernietaanzet;
 }