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;
}
}
}
}
}
public void poruszPionek(Pole dokad) //Metoda pozwalająca nam zmienić pole na którym stoi pionek/damka.
{
naJakimPoluPionek = dokad;
}
} //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 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());
}
