public static RuchDrzewo obliczRuchAI(List<Bierka> GraBiale, List<Bierka> GraCzarne)
        {
            List<RuchDrzewo> listaRuchow = new List<RuchDrzewo>();
            List<Bierka> listaCzarneNieRuszac = new List<Bierka>();
            listaCzarneNieRuszac = Tools.klonujBierki(GraCzarne);

            foreach (Bierka b1 in listaCzarneNieRuszac)
            {
                List<Point> listaP = new List<Point>();
                listaP = Tools.klonujPointy(b1.mozliweRuchy);

                List<Point> listaP1 = new List<Point>();
                listaP1 = Tools.klonujPointy(b1.mozliweBicia);

                foreach (Point p1 in listaP.Union(listaP1))
                {
                    bool biciePierwsze = false;
                    Bierka zbita = new Bierka();

                    List<Bierka> listaBiale1 = new List<Bierka>();
                    listaBiale1 = Tools.klonujBierki(GraBiale);
                    List<Bierka> listaCzarne1 = new List<Bierka>();
                    listaCzarne1 = Tools.klonujBierki(GraCzarne);

                    int xPoprzednie = b1.pozycjaX;
                    int yPoprzednie = b1.pozycjaY;

                    if (b1.mozliweBicia.Contains(p1))
                    {
                        zbita = Bierka.getBierkaByPos(p1.X, p1.Y, listaBiale1, listaCzarne1);
                        listaBiale1.Remove(zbita);
                        biciePierwsze = true;
                    }
                    else b1.przesun(p1.X, p1.Y, false);

                    Bierka.przeliczWszystieRuchy(listaBiale1, listaCzarne1);
                    RuchDrzewo rd = Gracz_Czlowiek.wykonajNajlepszyRuch(listaBiale1, listaCzarne1);
                    Bierka.przeliczWszystieRuchy(listaBiale1, listaCzarne1);

                    List<Bierka> listaBiale2 = new List<Bierka>();
                    listaBiale2 = Tools.klonujBierki(listaBiale1);
                    List<Bierka> listaCzarne2 = new List<Bierka>();
                    listaCzarne2 = Tools.klonujBierki(listaCzarne1);

                    foreach (Bierka b2 in listaCzarne2)
                    {
                        List<Point> listaP2 = new List<Point>();
                        listaP2 = Tools.klonujPointy(b2.mozliweRuchy);

                        List<Point> listaP3 = new List<Point>();
                        listaP3 = Tools.klonujPointy(b2.mozliweBicia);

                        foreach (Point p2 in listaP2.Union(listaP3))
                        {
                            bool bicie = false;
                            zbita = new Bierka();

                            int x = b2.pozycjaX;
                            int y = b2.pozycjaY;

                            if (b2.mozliweBicia.Contains(p2))
                            {
                                zbita = Bierka.getBierkaByPos(p2.X, p2.Y, listaBiale2, listaCzarne2);
                                listaBiale2.Remove(zbita);
                                bicie = true;
                            }
                            else b2.przesun(p2.X, p2.Y, false);

                            Bierka.przeliczWszystieRuchy(listaBiale2, listaCzarne2);

                            List<Bierka> listaBialeOstatnia = new List<Bierka>();
                            listaBialeOstatnia = Tools.klonujBierki(listaBiale2);
                            List<Bierka> listaCzarneOstatnia = new List<Bierka>();
                            listaCzarneOstatnia = Tools.klonujBierki(listaCzarne2);

                            rd = Gracz_Czlowiek.wykonajNajlepszyRuch(listaBialeOstatnia, listaCzarneOstatnia);
                            Bierka.przeliczWszystieRuchy(listaBialeOstatnia, listaCzarneOstatnia);

                            int bialePkt = Bierka.getPunktacjaListyBierek(listaBialeOstatnia, listaBialeOstatnia, listaCzarneOstatnia);
                            int czarnePkt = Bierka.getPunktacjaListyBierek(listaCzarneOstatnia, listaBialeOstatnia, listaCzarneOstatnia);

                            b1.pozycjaX = xPoprzednie;
                            b1.pozycjaY = yPoprzednie;
                            listaRuchow.Add(new RuchDrzewo(b1, p1, czarnePkt - bialePkt, biciePierwsze));

                            if (bicie) listaBiale2.Add(zbita);
                            else
                            {
                                b2.pozycjaX = x;
                                b2.pozycjaY = y;
                            }
                        }
                    }
                }
            }

            int max = 0;
            RuchDrzewo wybranyRuch = new RuchDrzewo(); // = listaRuchow[0];   // gdy jest remis

            if (listaRuchow.Count > 0) wybranyRuch = listaRuchow[0];  // gdy remis punktowy

            foreach (RuchDrzewo ruch in listaRuchow)
            {
                if (ruch.ile > max)
                {
                    max = ruch.ile;
                    wybranyRuch = ruch;
                }
            }

            // jak wszystko skonczone to przejrzyj liste elementow i znajdŸ max.
            return wybranyRuch;
        }
        public static RuchDrzewo wykonajNajlepszyRuch(List<Bierka> listaBiale, List<Bierka> listaCzarne)
        {
            int punktyMax = 0;
            Bierka wybrana = new Bierka();
            Point wybranyRuch = new Point();
            bool czyBicie = false;

              //  List<Bierka> listaBiale = new List<Bierka>();
              //  listaBiale = Tools.klonujBierki(Gra.bierkiBiale);

            foreach (Bierka b in listaBiale)
            {
                List<Point> listaP = new List<Point>();
                listaP = Tools.klonujPointy(b.mozliweRuchy);

                List<Point> listaP1 = new List<Point>();
                listaP1 = Tools.klonujPointy(b.mozliweBicia);

                int x = b.pozycjaX;
                int y = b.pozycjaY;

                foreach (Point p in listaP.Union(listaP1))
                {
                    bool bicie = false;
                   // List<Bierka> listaczarne = new List<Bierka>();
                   // listaczarne = Tools.klonujBierki(Gra.bierkiCzarne);
                    Bierka zbita = null;
                    bicie = false;

                    if (b.mozliweBicia.Contains(p))
                    {
                       zbita = Bierka.getBierkaByPos(p.X, p.Y, listaBiale, listaCzarne);
                       listaCzarne.Remove(zbita);
                       bicie = true;
                    }
                    else b.przesun(p.X, p.Y, false);

                    Bierka.przeliczWszystieRuchy(listaBiale, listaCzarne);

                    int wynikBiale = Bierka.getPunktacjaListyBierek(listaBiale, listaBiale, listaCzarne);
                    int wynikCzarne = Bierka.getPunktacjaListyBierek(listaCzarne, listaBiale, listaCzarne);

                    int roznica = wynikBiale - wynikCzarne;

                    if (punktyMax < roznica)
                    {
                        punktyMax = roznica;
                        wybrana = b;
                        wybranyRuch = p;
                        czyBicie = bicie;
                    }

                    // przywracam zbit¹ bierkê
                    if (zbita != null) listaCzarne.Add(zbita);

                    // cofam bierkê
                    b.pozycjaX = x;
                    b.pozycjaY = y;
                    Bierka.przeliczWszystieRuchy(listaBiale, listaCzarne);
                }
            }

            string pozycjaWybranej = Gra.tlumaczNazwePolaPGN(wybrana.pozycjaX, wybrana.pozycjaY);
            string pozycjadocelowa = Gra.tlumaczNazwePolaPGN(wybranyRuch.X, wybranyRuch.Y);

            RuchDrzewo ruch = new RuchDrzewo(wybrana, wybranyRuch, punktyMax, czyBicie);

            return ruch;
        }
Exemple #3
0
        // zbiór funkcji do obsługi ruchu wykonywanego przez komputer
        private void wykonajRuchPC()
        {
            if (uzywajSI)
            {

                RuchDrzewo rd = new RuchDrzewo();
                do
                {
                    // mechanizm losujący bierki przekazywane do funkcji obliczającej
                    List<Bierka> listaBiale = new List<Bierka>();
                    listaBiale = Tools.klonujBierki(Gra.bierkiBiale);

                    List<Bierka> listaCzarne = new List<Bierka>();
                    listaCzarne = Tools.klonujBierki(Gra.bierkiCzarne);

                    listaBiale = LosujBierki.zwrocListe(ileLosowac, listaBiale);
                    listaCzarne = LosujBierki.zwrocListe(ileLosowac, listaCzarne);

                    // zwrócenie najlepszego ruchu
                    rd = Gracz_Komputer.obliczRuchAI(listaBiale, listaCzarne);
                }
                while (rd.bierka == null);

                Bierka bi = Bierka.getBierkaByPos(rd.bierka.pozycjaX, rd.bierka.pozycjaY, Gra.bierkiBiale, Gra.bierkiCzarne);
                if (rd.czyBicie)
                {
                    try  // tutaj niestety czasem coś się psuje.
                    {  // komputer ma w którymś miejscu nieaktualną listę pionów (prawdopodobnie)
                        bi.zbij(Bierka.getBierkaByPos(bi.mozliweBicia[0].X, bi.mozliweBicia[0].Y, Gra.bierkiBiale, Gra.bierkiCzarne));
                    }
                    catch { MessageBox.Show("Wystąpił problem z mechanizmem SI. PC Oddaje ruch graczowi"); }
                    Gra.kolejka = Enums.czyjaKolej.Osoba;
                }
                else
                {
                    bi.przesun(rd.punkt.X, rd.punkt.Y, true);
                    Gra.kolejka = Enums.czyjaKolej.Osoba;
                }
            }
            else
            {
                if (!Gracz_Komputer.Zrob_RuchLosowy())
                {
                    MessageBox.Show("Wygrałeś !!");
                }
            }
        }