示例#1
0
        public Szachownica() //Konstruktor tworzacy dwuwymiarową tablicę obiektów typu Pole, która ma reprezentować rzeczywistą szachownicę.
        {
            Color kolorPola = Color.Black;

            for (int i = 0; i <= 7; i++)
            {
                for (int j = 0; j <= 7; j++)
                {
                    plansza[i, j] = new Pole(kolorPola);
                    if (j != 7)
                    {
                        if (kolorPola == Color.Black)
                        {
                            kolorPola = Color.BlanchedAlmond;
                        }
                        else
                        {
                            kolorPola = Color.Black;
                        }
                    }
                }
            }
        }
示例#2
0
 public void poruszPionek(Pole dokad) //Metoda pozwalająca nam zmienić pole na którym stoi pionek/damka.
 {
     naJakimPoluPionek = dokad;
 }
示例#3
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;
 }
示例#4
0
        public void sprawdzanieBiciaDamkiPrawoGora(Gracz wlasciciel, Pole sprawdzane, Pole oryginal, List <Pionek> listaDoZbicia, ref List <Ruch> bicie) //Metoda sprawdzająca bicie damki w kierunku Prawo-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 (czyWolne(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))
                    {
                        sprawdzanieBiciaDamkiPrawoGora(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))
                {
                    sprawdzanieBiciaDamkiPrawoGora(wlasciciel, plansza[para.Item1 + 1, para.Item2 - 1], oryginal, listaDoZbicia, ref bicie);
                }
            }
        }
        /// <summary>
        /// Rozpoznaje białe pola na warcabnicy.
        /// </summary>
        /// <returns>Ilość rozpoznanych pól.</returns>
        public int RozpoznajPola()
        {
            Mat obr = WczytajObraz();
            VectorOfVectorOfPoint kontury = new VectorOfVectorOfPoint();
            Mat wyciety = new Mat();

            AnalizujPlansze(obr, pola_min, pola_max, ref kontury, ref wyciety);

            if (kontury.Size != ILOSC_POL_KOLOR)
            {
                Plansza = null;
                return(kontury.Size);
            }

            Point[][] punkty       = kontury.ToArrayOfArray();
            Pole[]    biale        = new Pole[punkty.Length];
            int       srednia_szer = 0;
            int       srednia_wys  = 0;
            Pole      pole;

            Point[] pola = new Point[ILOSC_POL];

            //Oblicz srednie rozmiary pol bialych
            for (int i = 0; i < punkty.Length; i++)
            {
                pole          = new Pole(punkty[i].Min(p => p.X), punkty[i].Max(p => p.X), punkty[i].Min(p => p.Y), punkty[i].Max(p => p.Y));
                biale[i]      = pole;
                srednia_szer += pole.xmax - pole.xmin;
                srednia_wys  += pole.ymax - pole.ymin;
            }

            srednia_szer /= punkty.Length;
            srednia_wys  /= punkty.Length;

            //Wyznacz granice pol
            biale = biale.OrderBy(p => p.ymin).ToArray();
            Pole plansza_rozm = new Pole(biale.Min(p => p.xmin), biale.Max(p => p.xmax), biale.Min(p => p.ymin), biale.Max(p => p.ymax));

            Plansza = new Pole[POLA_WIERSZ, POLA_WIERSZ];
            int ixw = 0;
            int ixk = 0;

            for (int i = 0; i < biale.Length; i += 4)
            {
                Pole[] wiersz = new Pole[POLA_WIERSZ_KOLOR];
                for (int j = 0; j < POLA_WIERSZ_KOLOR; j++)
                {
                    wiersz[j] = biale[i + j];
                }
                wiersz = wiersz.OrderBy(p => p.xmin).ToArray();

                if (wiersz[0].xmin > (plansza_rozm.xmin + srednia_szer))      //W wierszu najpierw czarne
                {
                    Plansza[0, ixk] = new Pole(plansza_rozm.xmin, wiersz[0].xmin, wiersz[0].ymin, wiersz[0].ymax, KolorPola.czarne);

                    ixw = 1;
                    for (int j = 0; j < POLA_WIERSZ_KOLOR; j++)
                    {
                        Plansza[ixw, ixk] = new Pole(wiersz[j], KolorPola.biale);
                        ixw++;
                        if (j != POLA_WIERSZ_KOLOR - 1)
                        {
                            Plansza[ixw, ixk] = new Pole(wiersz[j].xmax, wiersz[j + 1].xmin, wiersz[j].ymin, wiersz[j].ymax, KolorPola.czarne);
                            ixw++;
                        }
                    }
                }
                else        //W wierszu najpierw biale
                {
                    ixw = 0;
                    for (int j = 0; j < POLA_WIERSZ_KOLOR; j++)
                    {
                        Plansza[ixw, ixk] = new Pole(wiersz[j], KolorPola.biale);
                        ixw++;
                        if (j != POLA_WIERSZ_KOLOR - 1)
                        {
                            Plansza[ixw, ixk] = new Pole(wiersz[j].xmax, wiersz[j + 1].xmin, wiersz[j].ymin, wiersz[j].ymax, KolorPola.czarne);
                            ixw++;
                        }
                    }

                    Plansza[7, ixk] = new Pole(wiersz[3].xmax, plansza_rozm.xmax, wiersz[3].ymin, wiersz[3].ymax, KolorPola.czarne);
                }

                ixk++;
            }

            return(punkty.Length);
        }
        /// <summary>
        /// Rozpoznaje pionki na planszy. Przed wywołaniem należy wywołać funkcję RozpoznajPola.
        /// </summary>
        /// <returns>Zwraca pozycje pionków na warcabnicy. Jeśli nie wywołano funkcji RozpoznajPola lub zwróciła ona inną wartość niż 32, funkcja zwraca null.</returns>
        public Pionek[] RozpoznajPionki()
        {
            if (Plansza == null)
            {
                return(null);
            }

            Mat obr = WczytajObraz();
            HashSet <Pionek> pionki = new HashSet <Pionek>();

            DanePionka[] dane = new DanePionka[] {
                new DanePionka()
                {
                    min = pionki_min, max = pionki_max, typ = TypObiektu.Pionki
                },
                new DanePionka()
                {
                    min = damki_min, max = damki_max, typ = TypObiektu.Damki
                },
                new DanePionka()
                {
                    min = pionki_wrog_min, max = pionki_wrog_max, typ = TypObiektu.PionkiWrog
                },
                new DanePionka()
                {
                    min = damki_wrog_min, max = damki_wrog_max, typ = TypObiektu.DamkiWrog
                }
            };

            for (int d = 0; d < dane.Length; d++)
            {
                VectorOfVectorOfPoint kontury = new VectorOfVectorOfPoint();
                Mat wyciety = new Mat();
                AnalizujPlansze(obr, dane[d].min, dane[d].max, ref kontury, ref wyciety);

                Point[][] punkty = kontury.ToArrayOfArray();
                Pole      pole;
                Point     srodek;
                Pole      pp;
                bool      znaleziono;

                for (int i = 0; i < punkty.Length; i++)
                {
                    pole       = new Pole(punkty[i].Min(p => p.X), punkty[i].Max(p => p.X), punkty[i].Min(p => p.Y), punkty[i].Max(p => p.Y));
                    srodek     = new Point(pole.xmin + (pole.xmax - pole.xmin) / 2, pole.ymin + (pole.ymax - pole.ymin) / 2);
                    znaleziono = false;

                    for (int x = 0; x < POLA_WIERSZ; x++)
                    {
                        for (int y = 0; y < POLA_WIERSZ; y++)
                        {
                            pp = Plansza[x, y];

                            if (pp.xmin < srodek.X && pp.xmax > srodek.X && pp.ymin < srodek.Y && pp.ymax > srodek.Y)
                            {
                                pionki.Add(new Pionek()
                                {
                                    x = x, y = y, typ = dane[d].typ
                                });
                                znaleziono = true;
                                break;
                            }
                        }

                        if (znaleziono)
                        {
                            break;
                        }
                    }
                }
            }

            return(pionki.ToArray());
        }