public void sprawdzanieBiciaDamkiLewoGora(Gracz wlasciciel, Pole sprawdzane, Pole oryginal, List <Pionek> listaDoZbicia, ref List <Ruch> bicie) //Metoda sprawdzająca bicie damki w kierunku Lewo-Góra
        {
            Tuple <int, int> para = zdobadzPozycje(sprawdzane);

            if (czyWPlanszy(sprawdzane, -2, -2))
            {
                if (czyWolne(sprawdzane, -2, -2) || czyPrzeznaczoneDoBicia(plansza[para.Item1 - 2, para.Item2 - 2], listaDoZbicia))
                {
                    if (czyCosObokDoZbicia(sprawdzane, -1, -1, wlasciciel) && !czyPrzeznaczoneDoBicia(plansza[para.Item1 - 1, para.Item2 - 1], listaDoZbicia))
                    {
                        listaDoZbicia.Add(zdobaczPionkaZPola(plansza[para.Item1 - 1, para.Item2 - 1]));
                        int wektorX = -2;
                        int wektorY = -2;
                        while (czyWPlanszy(sprawdzane, wektorX, wektorY) && (czyWolne(sprawdzane, wektorX, wektorY) || czyPrzeznaczoneDoBicia(plansza[para.Item1 + wektorX, para.Item2 + wektorY], listaDoZbicia)))
                        {
                            bicie.Add(new Ruch(oryginal, plansza[para.Item1 + wektorX, para.Item2 + wektorY], listaDoZbicia));
                            bicieDamka(wlasciciel, plansza[para.Item1 + wektorX, para.Item2 + wektorY], oryginal, listaDoZbicia, ref bicie);
                            wektorX--;
                            wektorY--;
                        }
                    }
                    else if (czyWolne(sprawdzane, -1, -1) || czyPrzeznaczoneDoBicia(plansza[para.Item1 - 1, para.Item2 - 1], listaDoZbicia))
                    {
                        sprawdzanieBiciaDamkiLewoGora(wlasciciel, plansza[para.Item1 - 1, para.Item2 - 1], oryginal, listaDoZbicia, ref bicie);
                    }
                }
                else if (czyWolne(sprawdzane, -1, -1) || czyPrzeznaczoneDoBicia(plansza[para.Item1 - 1, para.Item2 - 1], listaDoZbicia))
                {
                    sprawdzanieBiciaDamkiLewoGora(wlasciciel, plansza[para.Item1 - 1, para.Item2 - 1], oryginal, listaDoZbicia, ref bicie);
                }
            }
        }
        public void sprawdzanieBiciaPionekLewo(Gracz wlasciciel, Pole sprawdzane, Pole oryginal, List <Pionek> listaDoZbicia, ref List <Ruch> bicia) //Rekurencyjna metoda sprawdzająca możliwość bicia w lewo
        {
            if (wlasciciel.czyJestemCzlowiekiem)
            {
                if (czyWPlanszy(sprawdzane, -2, -2) && czyWolne(sprawdzane, -2, -2))
                {
                    if (czyCosObokDoZbicia(sprawdzane, -1, -1, wlasciciel))
                    {
                        Tuple <int, int> para = zdobadzPozycje(sprawdzane);
                        listaDoZbicia.Add(zdobaczPionkaZPola(plansza[para.Item1 - 1, para.Item2 - 1]));
                        bicia.Add(new Ruch(oryginal, plansza[para.Item1 - 2, para.Item2 - 2], listaDoZbicia));
                        sprawdzanieBiciaPionek(wlasciciel, plansza[para.Item1 - 2, para.Item2 - 2], oryginal, listaDoZbicia, ref bicia);
                    }
                }
            }

            else if (wlasciciel.czyJestemCzlowiekiem == false)
            {
                if (czyWolne(sprawdzane, -2, 2) && czyWolne(sprawdzane, -2, 2))
                {
                    if (czyCosObokDoZbicia(sprawdzane, -1, 1, wlasciciel))
                    {
                        Tuple <int, int> para = zdobadzPozycje(sprawdzane);
                        listaDoZbicia.Add(zdobaczPionkaZPola(plansza[para.Item1 - 1, para.Item2 + 1]));
                        bicia.Add(new Ruch(oryginal, plansza[para.Item1 - 2, para.Item2 + 2], listaDoZbicia));
                        sprawdzanieBiciaPionek(wlasciciel, plansza[para.Item1 - 2, para.Item2 + 2], oryginal, listaDoZbicia, ref bicia);
                    }
                }
            }
        }
        public List <Ruch> sprawdzanieRuchow(Gracz wlasciciel, Pole sprawdzane) //Metoda sprawdzająca wszystkie ruchy (bez bicia) dla pionka
        {
            List <Ruch> listaRuchow = new List <Ruch>();

            if (wlasciciel.czyJestemCzlowiekiem)
            {
                if (czyWPlanszy(sprawdzane, -1, -1) && czyWolne(sprawdzane, -1, -1))
                {
                    Tuple <int, int> para = zdobadzPozycje(sprawdzane);
                    listaRuchow.Add(new Ruch(sprawdzane, plansza[para.Item1 - 1, para.Item2 - 1], new List <Pionek>()));
                }
                if (czyWPlanszy(sprawdzane, 1, -1) && czyWolne(sprawdzane, 1, -1))
                {
                    Tuple <int, int> para = zdobadzPozycje(sprawdzane);
                    listaRuchow.Add(new Ruch(sprawdzane, plansza[para.Item1 + 1, para.Item2 - 1], new List <Pionek>()));
                }
            }
            else
            {
                if (czyWolne(sprawdzane, -1, 1) && czyWPlanszy(sprawdzane, -1, 1))
                {
                    Tuple <int, int> para = zdobadzPozycje(sprawdzane);
                    listaRuchow.Add(new Ruch(sprawdzane, plansza[para.Item1 - 1, para.Item2 + 1], new List <Pionek>()));
                }
                if (czyWolne(sprawdzane, 1, 1) && czyWPlanszy(sprawdzane, 1, 1))
                {
                    Tuple <int, int> para = zdobadzPozycje(sprawdzane);
                    listaRuchow.Add(new Ruch(sprawdzane, plansza[para.Item1 + 1, para.Item2 + 1], new List <Pionek>()));
                }
            }
            return(listaRuchow);
        }
        public void sprawdzanieBiciaDamkiPrawoDol(Gracz wlasciciel, Pole sprawdzane, Pole oryginal, List <Pionek> listaDoZbicia, ref List <Ruch> bicie) //Metoda sprawdzająca bicie damki w kierunku Prawo-Dół
        {
            Tuple <int, int> para = zdobadzPozycje(sprawdzane);

            if (czyWPlanszy(sprawdzane, 2, 2))
            {
                if (czyWolne(sprawdzane, 2, 2) || czyPrzeznaczoneDoBicia(plansza[para.Item1 + 2, para.Item2 + 2], listaDoZbicia))
                {
                    if (czyCosObokDoZbicia(sprawdzane, 1, 1, wlasciciel) && !czyPrzeznaczoneDoBicia(plansza[para.Item1 + 1, para.Item2 + 1], listaDoZbicia))
                    {
                        listaDoZbicia.Add(zdobaczPionkaZPola(plansza[para.Item1 + 1, para.Item2 + 1]));
                        int wektorX = 2;
                        int wektorY = 2;
                        while (czyWPlanszy(sprawdzane, wektorX, wektorY) && (czyWolne(sprawdzane, wektorX, wektorY) || czyPrzeznaczoneDoBicia(plansza[para.Item1 + wektorX, para.Item2 + wektorY], listaDoZbicia)))
                        {
                            bicie.Add(new Ruch(oryginal, plansza[para.Item1 + wektorX, para.Item2 + wektorY], listaDoZbicia));
                            bicieDamka(wlasciciel, plansza[para.Item1 + wektorX, para.Item2 + wektorY], oryginal, listaDoZbicia, ref bicie);
                            wektorX++;
                            wektorY++;
                        }
                    }
                    else if (czyWolne(sprawdzane, 1, 1) || czyPrzeznaczoneDoBicia(plansza[para.Item1 + 1, para.Item2 + 1], listaDoZbicia))
                    {
                        sprawdzanieBiciaDamkiPrawoDol(wlasciciel, plansza[para.Item1 + 1, para.Item2 + 1], oryginal, listaDoZbicia, ref bicie);
                    }
                }
                else if (czyWolne(sprawdzane, 1, 1) || czyPrzeznaczoneDoBicia(plansza[para.Item1 + 1, para.Item2 + 1], listaDoZbicia))
                {
                    sprawdzanieBiciaDamkiPrawoDol(wlasciciel, plansza[para.Item1 + 1, para.Item2 + 1], oryginal, listaDoZbicia, ref bicie);
                }
            }
        }
        public void bicieDamka(Gracz wlasciciel, Pole sprawdzane, Pole oryginal, List <Pionek> listaDoZbicia, ref List <Ruch> bicie) //Metoda wywołująca metody sprawdzające możliwości bicia damki w każdym z 4 kierunków.
        {
            List <Pionek> nowaLista = new List <Pionek>();

            foreach (var a in listaDoZbicia)
            {
                nowaLista.Add(a);
            }
            List <Pionek> nowaLista2 = new List <Pionek>();

            foreach (var a in listaDoZbicia)
            {
                nowaLista2.Add(a);
            }
            List <Pionek> nowaLista3 = new List <Pionek>();

            foreach (var a in listaDoZbicia)
            {
                nowaLista3.Add(a);
            }
            List <Pionek> nowaLista4 = new List <Pionek>();

            foreach (var a in listaDoZbicia)
            {
                nowaLista4.Add(a);
            }
            sprawdzanieBiciaDamkiLewoDol(wlasciciel, sprawdzane, oryginal, nowaLista, ref bicie);
            sprawdzanieBiciaDamkiLewoGora(wlasciciel, sprawdzane, oryginal, nowaLista2, ref bicie);
            sprawdzanieBiciaDamkiPrawoGora(wlasciciel, sprawdzane, oryginal, nowaLista3, ref bicie);
            sprawdzanieBiciaDamkiPrawoDol(wlasciciel, sprawdzane, oryginal, nowaLista4, ref bicie);
        }
 public bool czyJestPionekTegoPana(Gracz kto, Pole gdzie) //Metoda sprawdzająca czy na podanym polu znajduje się pionek danego gracza.
 {
     foreach (var a in wszystkiePionki)
     {
         if (a.polePionka == gdzie && a.czyjJestTenPionek == kto)
         {
             return(true);
         }
     }
     return(false);
 }
Exemple #7
0
 }                           //Właściwość pozwalająca dowiedzieć się kto aktualnie ma wykonać ruch
 public void zmianaKolejki() //Metoda zmieniająca który gracz ma teraz wykonać ruch
 {
     graczPrzyKolejce.czyszczenieRuchow();
     if (graczPrzyKolejce == humanPlayer)
     {
         graczPrzyKolejce = computerPlayer;
     }
     else
     {
         graczPrzyKolejce = humanPlayer;
     }
     graczPrzyKolejce.MozliweBicia(gameBoard);
 }
Exemple #8
0
        IPlayer white = new MinMaxCheckers(10); //new NeuralNetwork("jeden");

        #endregion Fields

        #region Constructors

        public MainForm()
        {
            InitializeComponent();

            konfig = new Konfiguracja();
            plansza = new Plansza();

            ruchy = new Ruchy();
            bicia = new Bicia();
            gracz = new Gracz(2);
            gracz.Prepare(plansza, this);
             //   gracz.IsComputer1 = true;
             //   gracz.IsComputer2 = false;
            nowaToolStripMenuItem_Click(null, null);
        }
        public void sprawdzanieBiciaPionek(Gracz wlasciciel, Pole sprawdzane, Pole oryginal, List <Pionek> listaDoZbicia, ref List <Ruch> bicia) //Metoda wywołująca metody sprawdzające możliwość bicia pionka na lewo i prawo.
        {
            List <Pionek> nowaLista = new List <Pionek>();

            foreach (var a in listaDoZbicia)
            {
                nowaLista.Add(a);
            }
            List <Pionek> nowaLista2 = new List <Pionek>();

            foreach (var a in listaDoZbicia)
            {
                nowaLista2.Add(a);
            }

            sprawdzanieBiciaPionekLewo(wlasciciel, sprawdzane, oryginal, nowaLista, ref bicia);
            sprawdzanieBiciaPionekPrawo(wlasciciel, sprawdzane, oryginal, nowaLista2, ref bicia);
        }
Exemple #10
0
 public void kolorZostalWybrany(Color wybranyKolor) //Metoda tworząca obiekty graczy w zależności od wybranego przez człowieka koloru.
 {
     if (wybranyKolor == Color.Black)
     {
         humanPlayer      = new Gracz(true, wybranyKolor);
         computerPlayer   = new Gracz(false, Color.BlanchedAlmond);
         graczPrzyKolejce = computerPlayer;
     }
     else
     {
         humanPlayer      = new Gracz(true, wybranyKolor);
         computerPlayer   = new Gracz(false, Color.Black);
         graczPrzyKolejce = humanPlayer;
     }
     gameBoard.ustawPionki(humanPlayer, computerPlayer);
     graczPrzyKolejce.MozliweBicia(gameBoard);
     if (graczPrzyKolejce == computerPlayer)
     {
         ruchAI();
         zmianaKolejki();
     }
 }
        public List <Ruch> ruchDamka(Gracz wlasciciel, Pole sprawdzane) //Metoda sprawdzająca możliwe ruchy (bez bić) dla damki.
        {
            Tuple <int, int> para        = zdobadzPozycje(sprawdzane);
            List <Ruch>      zbiorRuchow = new List <Ruch>();
            int wektorX = -1;
            int wektorY = -1;

            while (czyWPlanszy(sprawdzane, wektorX, wektorY) && czyWolne(sprawdzane, wektorX, wektorY))
            {
                zbiorRuchow.Add(new Ruch(sprawdzane, plansza[para.Item1 + wektorX, para.Item2 + wektorY], new List <Pionek>()));
                wektorX--;
                wektorY--;
            }
            wektorX = -1;
            wektorY = 1;
            while (czyWPlanszy(sprawdzane, wektorX, wektorY) && czyWolne(sprawdzane, wektorX, wektorY))
            {
                zbiorRuchow.Add(new Ruch(sprawdzane, plansza[para.Item1 + wektorX, para.Item2 + wektorY], new List <Pionek>()));
                wektorX--;
                wektorY++;
            }
            wektorX = 1;
            wektorY = -1;
            while (czyWPlanszy(sprawdzane, wektorX, wektorY) && czyWolne(sprawdzane, wektorX, wektorY))
            {
                zbiorRuchow.Add(new Ruch(sprawdzane, plansza[para.Item1 + wektorX, para.Item2 + wektorY], new List <Pionek>()));
                wektorX++;
                wektorY--;
            }
            wektorX = 1;
            wektorY = 1;
            while (czyWPlanszy(sprawdzane, wektorX, wektorY) && czyWolne(sprawdzane, wektorX, wektorY))
            {
                zbiorRuchow.Add(new Ruch(sprawdzane, plansza[para.Item1 + wektorX, para.Item2 + wektorY], new List <Pionek>()));
                wektorX++;
                wektorY++;
            }
            return(zbiorRuchow);
        }
 public void ustawPionki(Gracz nowywlascicielHuman, Gracz nowyWlascicielComputer) //Metoda ustawiająca pionki na pozycjach startowych dla każdego gracza.
 {
     for (int i = 0; i <= 7; i++)
     {
         for (int j = 5; j <= 7; j++)
         {
             if (plansza[i, j].jakiKolorMaPole == Color.BlanchedAlmond)
             {
                 wszystkiePionki.Add(new Pionek(nowywlascicielHuman, plansza[i, j], false));
             }
         }
     }
     for (int i = 0; i <= 7; i++)
     {
         for (int j = 0; j <= 2; j++)
         {
             if (plansza[i, j].jakiKolorMaPole == Color.BlanchedAlmond)
             {
                 wszystkiePionki.Add(new Pionek(nowyWlascicielComputer, plansza[i, j], false));
             }
         }
     }
 }
Exemple #13
0
        /// <summary>
        /// Obsługuje klikniecie na planszy
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="p">Plansza</param>
        /// <param name="b">Bicia</param>
        /// <param name="gracz">Obecny gracz</param>
        /// <returns></returns>
        public void klikniecie(int x, int y, Plansza p, Bicia b, Gracz gracz, bool computer=false)
        {
            b.sprawdz_bicia(gracz, p);

            if (this.pole[x, y] == 0)//pierwszy klik
            {
                this.zerowanie();
                if (p.pole[x, y] > 1) //jezeli w polu znajduje sie pionek
                {
                    this.pole[x, y] = 1; // zaznaczam w ruchach miejsce

                    //jezeli jest to pionek gracza 1 i jest jego ruch
                    if (p.pole[x, y] == 2 && gracz.get_gracz() == 1)
                    {//dodajemy  do planszy ruchów 2 jak ruch bez bicia, 3 jak ruch z biciem
                        if (x > 0 && y > 0 && p.pole[x - 1, y - 1] == 1 && !b.przymus)
                        {
                            this.pole[x - 1, y - 1] = 2;
                            Move m = new Move(new Point(x, y));
                            m.moves.Add(new Point(x - 1, y - 1));
                            p.possibleMoves.Add(m);
                        }

                        if (x < 7 && y > 0 && p.pole[x + 1, y - 1] == 1 && !b.przymus)
                        {
                            this.pole[x + 1, y - 1] = 2;
                            Move m = new Move(new Point(x, y));
                            m.moves.Add(new Point(x + 1, y - 1));
                            p.possibleMoves.Add(m);
                        }

                        if (x > 1 && y > 1 && (p.pole[x - 1, y - 1] == 3
                            || p.pole[x - 1, y - 1] == 5) && p.pole[x - 2, y - 2] == 1)
                        {
                            this.pole[x - 2, y - 2] = 3;
                            Move m = new Move(new Point(x, y));
                            m.moves.Add(new Point(x - 2, y - 2));
                            p.possibleBeats.Add(m);
                        }

                        if (x < 6 && y > 1 && (p.pole[x + 1, y - 1] == 3
                            || p.pole[x + 1, y - 1] == 5) && p.pole[x + 2, y - 2] == 1)
                        {
                            this.pole[x + 2, y - 2] = 3;
                            Move m = new Move(new Point(x, y));
                            m.moves.Add(new Point(x + 2, y - 2));
                            p.possibleBeats.Add(m);
                        }

                        if (x > 1 && y < 6 && (p.pole[x - 1, y + 1] == 3
                            || p.pole[x - 1, y + 1] == 5) && p.pole[x - 2, y + 2] == 1)
                        {
                            this.pole[x - 2, y + 2] = 3;
                            Move m = new Move(new Point(x, y));
                            m.moves.Add(new Point(x - 2, y + 2));
                            p.possibleBeats.Add(m);
                        }

                        if (x < 6 && y < 6 && (p.pole[x + 1, y + 1] == 3
                            || p.pole[x + 1, y + 1] == 5) && p.pole[x + 2, y + 2] == 1)
                        {
                            this.pole[x + 2, y + 2] = 3;
                             Move m = new Move(new Point(x, y));
                            m.moves.Add(new Point(x + 2, y +2));
                            p.possibleBeats.Add(m);

                        }

                    }
                    //jezeli jest to pionek racza 2
                    else if (p.pole[x, y] == 3 && gracz.get_gracz() == 2)
                    {
                        if (x > 0 && y < 7 && p.pole[x - 1, y + 1] == 1 && !b.przymus)
                        {
                            this.pole[x - 1, y + 1] = 2;
                            Move m = new Move(new Point(x, y));
                            m.moves.Add(new Point(x - 1, y + 1));
                            p.possibleMoves.Add(m);
                        }

                        if (x < 7 && y < 7 && p.pole[x + 1, y + 1] == 1 && !b.przymus)
                        {
                            this.pole[x + 1, y + 1] = 2;
                            Move m = new Move(new Point(x, y));
                            m.moves.Add(new Point(x + 1, y + 1));
                            p.possibleMoves.Add(m);
                        }
                        if (x > 1 && y < 6 && (p.pole[x - 1, y + 1] == 2
                            || p.pole[x - 1, y + 1] == 4) && p.pole[x - 2, y + 2] == 1)
                        {
                            this.pole[x - 2, y + 2] = 3;
                             Move m = new Move(new Point(x, y));
                            m.moves.Add(new Point(x - 2, y + 2));
                            p.possibleBeats.Add(m);
                        }

                        if (x < 6 && y < 6 && (p.pole[x + 1, y + 1] == 2
                            || p.pole[x + 1, y + 1] == 4) && p.pole[x + 2, y + 2] == 1)
                        {
                            this.pole[x + 2, y + 2] = 3;
                             Move m = new Move(new Point(x, y));
                            m.moves.Add(new Point(x + 2, y + 2));
                            p.possibleBeats.Add(m);
                        }

                        if (x > 1 && y > 1 && (p.pole[x - 1, y - 1] == 2
                            || p.pole[x - 1, y - 1] == 4) && p.pole[x - 2, y - 2] == 1)
                        {
                            this.pole[x - 2, y - 2] = 3;
                             Move m = new Move(new Point(x, y));
                            m.moves.Add(new Point(x - 2, y - 2));
                            p.possibleBeats.Add(m);
                        }

                        if (x < 6 && y > 1 && (p.pole[x + 1, y - 1] == 2
                            || p.pole[x + 1, y - 1] == 4) && p.pole[x + 2, y - 2] == 1)
                        {
                            this.pole[x + 2, y - 2] = 3;
                             Move m = new Move(new Point(x, y));
                            m.moves.Add(new Point(x + 2, y - 2));
                            p.possibleBeats.Add(m);
                        }
                    }
                    //jezeli jest to damka gracza 1 lub gracza 2 i to jest jego ruch
                    else if ((p.pole[x, y] == 4 && gracz.get_gracz() == 1) || (p.pole[x, y] == 5 && gracz.get_gracz() == 2))
                    {
                        int i = 0; int j = 0;
                        int add = (gracz.get_gracz() == 1) ? 1 : 0;

                        while (!b.przymus && x + i > 0 && y + j > 0)//markuje na 2 te pola na których może stanąć
                        {
                            if (p.pole[x + i - 1, y + j - 1] == 1)//puste pole na planszy
                            {
                                this.pole[x + i - 1, y + j - 1] = 2;
                                Move m = new Move(new Point(x, y));
                                m.moves.Add(new Point(x + i - 1, y + j - 1));
                                p.possibleMoves.Add(m);

                                --i;
                                --j;
                            }
                            else break;
                        }

                        i = 0; j = 0;

                        while (!b.przymus && x + i < 7 && y + j > 0)
                        {
                            if (p.pole[x + i + 1, y + j - 1] == 1)
                            {
                                this.pole[x + i + 1, y + j - 1] = 2;
                                Move m = new Move(new Point(x, y));
                                m.moves.Add(new Point(x + i + 1, y + j - 1));
                                p.possibleMoves.Add(m);
                                ++i;
                                --j;
                            }
                            else break;
                        }

                        i = 0; j = 0;

                        while (!b.przymus && x + i > 0 && y + j < 7)
                        {
                            if (p.pole[x + i - 1, y + j + 1] == 1)
                            {
                                this.pole[x + i - 1, y + j + 1] = 2;
                                Move m = new Move(new Point(x, y));
                                m.moves.Add(new Point(x + i - 1, y + j + 1));
                                p.possibleMoves.Add(m);
                                --i;
                                ++j;
                            }
                            else break;
                        }

                        i = 0; j = 0;

                        while (!b.przymus && x + i < 7 && y + j < 7)
                        {
                            if (p.pole[x + i + 1, y + j + 1] == 1)
                            {
                                this.pole[x + i + 1, y + j + 1] = 2;
                                Move m = new Move(new Point(x, y));
                                m.moves.Add(new Point(x + i + 1, y + j + 1));
                                p.possibleMoves.Add(m);
                                ++i;
                                ++j;
                            }
                            else break;
                        }

                        bool bij = false; i = 0; j = 0;

                        while (x + i > 0 && y + j > 0)//jak jest bicie markuje na 3 pola na których może stanąć po biciu
                        {
                            if (p.pole[x + i - 1, y + j - 1] == 1)
                            {
                                if (bij)
                                {
                                    this.pole[x + i - 1, y + j - 1] = 3;
                                    Move m = new Move(new Point(x, y));
                                    m.moves.Add(new Point(x + i - 1, y + j - 1));
                                    p.possibleBeats.Add(m);
                                }
                                --i;
                                --j;
                            }
                            else if (p.pole[x + i - 1, y + j - 1] == 2 + add || p.pole[x + i - 1, y + j - 1] == 4 + add)
                            {
                                if (!bij)
                                {
                                    bij = true;
                                    --i;
                                    --j;
                                }
                                else break;
                            }
                            else break;
                        }

                        bij = false; i = 0; j = 0;

                        while (x + i < 7 && y + j > 0)
                        {
                            if (p.pole[x + i + 1, y + j - 1] == 1)
                            {
                                if (bij)
                                {
                                    this.pole[x + i + 1, y + j - 1] = 3;
                                    Move m = new Move(new Point(x, y));
                                    m.moves.Add(new Point(x + i + 1, y + j - 1));
                                    p.possibleBeats.Add(m);
                                }
                                ++i;
                                --j;
                            }
                            else if (p.pole[x + i + 1, y + j - 1] == 2 + add || p.pole[x + i + 1, y + j - 1] == 4 + add)
                            {
                                if (!bij)
                                {
                                    bij = true;
                                    ++i;
                                    --j;
                                }
                                else break;
                            }
                            else break;
                        }

                        bij = false; i = 0; j = 0;

                        while (x + i > 0 && y + j < 7)
                        {
                            if (p.pole[x + i - 1, y + j + 1] == 1)
                            {
                                if (bij)
                                {
                                    this.pole[x + i - 1, y + j + 1] = 3;
                                    Move m = new Move(new Point(x, y));
                                    m.moves.Add(new Point(x + i - 1, y + j + 1));
                                    p.possibleBeats.Add(m);
                                }
                                --i;
                                ++j;
                            }
                            else if (p.pole[x + i - 1, y + j + 1] == 2 + add || p.pole[x + i - 1, y + j + 1] == 4 + add)
                            {
                                if (!bij)
                                {
                                    bij = true;
                                    --i;
                                    ++j;
                                }
                                else break;
                            }
                            else break;
                        }

                        bij = false; i = 0; j = 0;

                        while (x + i < 7 && y + j < 7)
                        {
                            if (p.pole[x + i + 1, y + j + 1] == 1)
                            {
                                if (bij)
                                {
                                    this.pole[x + i + 1, y + j + 1] = 3;
                                    Move m = new Move(new Point(x, y));
                                    m.moves.Add(new Point(x + i + 1, y + j + 1));
                                    p.possibleBeats.Add(m);
                                }
                                ++i;
                                ++j;
                            }
                            else if (p.pole[x + i + 1, y + j + 1] == 2 + add || p.pole[x + i + 1, y + j + 1] == 4 + add)
                            {
                                if (!bij)
                                {
                                    bij = true;
                                    ++i;
                                    ++j;
                                }
                                else break;
                            }
                            else break;
                        }
                    }

              //      this.wyswietlanie();
                }

                old_x = x;
                old_y = y;
            }/*
            else if (this.pole[x,y] == 1)
            {
                this.zerowanie();
            }*/
            else if (this.pole[x, y] == 2)//wykonanie ruchu, bo na pole można się ruszyć bez bicia
            {
                p.pole[x, y] = p.pole[old_x, old_y];
                p.pole[old_x, old_y] = 1;
                this.zerowanie();
                p.zamien_pionki_na_damki(gracz);
            //        gracz.zmiana_gracza(computer);
            }
            else if (this.pole[x, y] == 3)//wykonanie bicia
            {
                p.pole[x, y] = p.pole[old_x, old_y];
                int i = old_x;
                int j = old_y;
                int add_i = (old_x < x) ? 1 : -1;
                int add_j = (old_y < y) ? 1 : -1;
                int kill_x = i + add_i;
                int kill_y = j + add_j;
                while (kill_x != x && kill_y != y)
                {
                    p.pole[kill_x, kill_y] = 1;
                    kill_x += add_i;
                    kill_y += add_j;
                    //			System.out.println("kiler : " + kill_x + " " + kill_y);
                }
                p.pole[old_x, old_y] = 1;

                this.zerowanie();
                b.sprawdz_bicia(gracz, p, x, y);//zmiana gracza po biciu
                if (!b.przymus)
                {
                    p.zamien_pionki_na_damki(gracz);
            //        gracz.zmiana_gracza(computer);
                }
                else//kolejny ruch
                {
                    klikniecie(x, y, p, b, gracz,computer);
                }
            }

            b.sprawdz_bicia(gracz, p);
        }
Exemple #14
0
 }                                                                  //Właściwość pozwalająca nam odczytać na jakim polu znajduje się aktualnie pionek/damka.
 public Pionek(Gracz nowyWlasciciel, Pole mojNowyDomek, bool damka) //Konstruktor przypisujący pole na którym jest pionek, właściciela oraz czy jest to damka czy nie.
 {
     naJakimPoluPionek = mojNowyDomek;
     wlasciciel        = nowyWlasciciel;
     czyDamka          = damka;
 }
 public void wczytajDamke(Gracz wlasciciel, int i, int j) // metoda pozwalajaca ustawić damki i przypisac je wlascicielowi wczytując gre
 {
     wszystkiePionki.Add(new Pionek(wlasciciel, plansza[i, j], true));
 }
Exemple #16
0
        public void sprawdz_bicia(Gracz gracz, Plansza p, int x, int y)
        {
            zerowanie();
            przymus = false;

            this.pole[x, y] = get_bicia(x, y, p);
        }
        public bool czyCosObokDoZbicia(Pole sprawdzany, int roznicadlaX, int roznicadlaY, Gracz wlascicielspr) //Metoda sprawdzająca czy na polu którę znajduję się o podany wektor od podanego pola znajduje się pionek gracza przeciwnego.
        {
            Tuple <int, int> para = zdobadzPozycje(sprawdzany);

            foreach (var b in wszystkiePionki)
            {
                if (b.polePionka == plansza[para.Item1 + roznicadlaX, para.Item2 + roznicadlaY] && b.czyjJestTenPionek != wlascicielspr)
                {
                    return(true);
                }
            }
            return(false);
        }
Exemple #18
0
        public void odczyt() // metoda pozwalająca wczytać uprzednio zapisany stan gry
        {
            OpenFileDialog openFileDialog1 = new OpenFileDialog();

            openFileDialog1.Filter           = "txt files (*.txt)|*.txt|All files (*.*)|*.*";
            openFileDialog1.InitialDirectory = Application.StartupPath;
            DialogResult czyok = openFileDialog1.ShowDialog();

            if (czyok == DialogResult.OK)
            {
                string       plik   = openFileDialog1.FileName;
                StreamReader czytaj = new StreamReader(plik);
                gameBoard.wyczysc();
                string pierwszy, tekst;
                pierwszy = czytaj.ReadLine();
                if (pierwszy != null)
                {
                    if (pierwszy.Equals("b"))
                    {
                        humanPlayer    = new Gracz(true, Color.Black);
                        computerPlayer = new Gracz(false, Color.BlanchedAlmond);
                    }
                    else if (pierwszy.Equals("w"))
                    {
                        humanPlayer    = new Gracz(true, Color.BlanchedAlmond);
                        computerPlayer = new Gracz(false, Color.Black);
                    }
                    for (int j = 0; j < 8; j++)
                    {
                        for (int i = 0; i < 10; i++)
                        {
                            int sczytane = czytaj.Read();
                            if (sczytane.Equals('a'))
                            {
                                gameBoard.wczytajPionek(humanPlayer, i, j);
                            }
                            if (sczytane.Equals('q'))
                            {
                                gameBoard.wczytajPionek(computerPlayer, i, j);
                            }
                            if (sczytane.Equals('d'))
                            {
                                gameBoard.wczytajDamke(humanPlayer, i, j);
                            }
                            if (sczytane.Equals('g'))
                            {
                                gameBoard.wczytajDamke(computerPlayer, i, j);
                            }
                        }
                    }
                    tekst = czytaj.ReadLine();
                    if (tekst != null)
                    {
                        if (tekst.Equals("h"))
                        {
                            graczPrzyKolejce = humanPlayer;
                            graczPrzyKolejce.MozliweBicia(gameBoard);
                        }
                        else if (tekst.Equals("c"))
                        {
                            graczPrzyKolejce = computerPlayer;
                            ruchAI();
                            zmianaKolejki();
                        }
                    }
                    czytaj.Close();
                }
            }
        }
Exemple #19
0
        public void sprawdz_bicia(Gracz gracz, Plansza p)
        {
            zerowanie();
            przymus = false;

            for (int j = 0; j < 8; j++)
                for (int i = 0; i < 8; i++)
                {
                    if ((gracz.get_gracz() + 1) == p.pole[i, j] || (gracz.get_gracz() + 3) == p.pole[i, j])
                        this.pole[i, j] = get_bicia(i, j, p);
                    else
                        this.pole[i, j] = 0;
                    if (pole[i, j] != 0)
                        przymus = true;
                }
            //		this.wyswietlanie();
        }