static public 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);
        }
Example #2
0
        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);
        }