Example #1
0
        public Move MakeMove(Plansza p, int gracz)
        {
            List<Move> moves = p.GenerateAllMoves(gracz);// generuje wszystkie mozliwe ruchy
            List<Move> sameGood = new List<Move>();
            Random r = new Random(DateTime.Now.Second);//losowanie ktore wybrac gdy dwa ruchy sa tak samo punktowane
            int best = Int32.MinValue;
            me = gracz;

            foreach (Move m in moves)
            {
                //alphabeta(origin, depth, -infinity, +infinity, MaxPlayer)
                Plansza clone = p.Clone();
                clone.ExecuteMove(m);
                int ret = alphabeta2(clone, false, Int32.MinValue, Int32.MaxValue, maxDepth-1); //udoskonalenie minmaxa
                if (ret > best)
                {
                    sameGood = new List<Move>();
                    best = ret;
                    sameGood.Add(m);
                }
                else if (ret == best)
                {
                    sameGood.Add(m);
                }
            }
            if (sameGood.Count == 0)
            {
                return null;
            }
            return sameGood[r.Next(sameGood.Count)];
        }
Example #2
0
        public void TestWykonaniaKrotkiejRoszady()
        {
            //tworzenie danych
            List <Bierka> listaBierek = new List <Bierka>();
            Plansza       plansza     = new Plansza(null, Wygrana, listaBierek);

            //dodawanie bierek na stol
            listaBierek.Add(new Wieza(new Punkt(0, 0), Strona.Czarna, plansza));
            listaBierek.Add(new Wieza(new Punkt(7, 0), Strona.Czarna, plansza));
            listaBierek.Add(new Wieza(new Punkt(0, 7), Strona.Biała, plansza));
            listaBierek.Add(new Wieza(new Punkt(7, 7), Strona.Biała, plansza));
            listaBierek.Add(new Krol(new Punkt(4, 0), Strona.Czarna, plansza));
            listaBierek.Add(new Krol(new Punkt(4, 7), Strona.Biała, plansza));
            for (int i = 0; i < 8; i++)
            {
                listaBierek.Add(new Pionek(new Punkt(i, 1), Strona.Czarna, plansza));
            }
            for (int i = 0; i < 8; i++)
            {
                listaBierek.Add(new Pionek(new Punkt(i, 6), Strona.Biała, plansza));
            }
            plansza.TestRuchow();
            //sprawdzanie poprawnosci danych
            Assert.IsTrue(plansza.SprobujWykonacRuch(new Punkt(4, 7), new Punkt(6, 7)));
            Assert.IsTrue(plansza.SprobujWykonacRuch(new Punkt(4, 0), new Punkt(6, 0)));
        }
Example #3
0
        public void BlocksHorVerTest_Kolejka_vertical_czy_prawidlowe_liczby()
        {
            bool    actual = true;
            Plansza target = new Plansza();

            target.BlocksHorVer(7, 8, 4);

            int a = 8 - (8 % 3);

            for (int i = a; i <= a + 2; i++)
            {
                for (int j = 0; j < 9; j++)
                {
                    if (a != i)
                    {
                        if (target.vertical.Peek() != target.sud[i, j])
                        {
                            actual = false;
                        }
                        target.vertical.Enqueue(target.vertical.Peek());
                        target.vertical.Dequeue();
                    }
                }
            }
            Assert.IsTrue(actual);
        }
Example #4
0
        public void TestRuchowHetmanaOgraniczonegoInnymiBierkamiInnegoKoloru(int x, int y)
        {
            //tworzenie danych
            List <Bierka> listaBierek = new List <Bierka>();
            Plansza       plansza     = new Plansza(null, null, listaBierek);

            //dodawanie bierek na stol
            listaBierek.Add(new Hetman(new Punkt(4, 4), Strona.Biała, plansza));

            listaBierek.Add(new Hetman(new Punkt(6, 4), Strona.Czarna, plansza));
            listaBierek.Add(new Hetman(new Punkt(2, 4), Strona.Czarna, plansza));
            listaBierek.Add(new Hetman(new Punkt(4, 6), Strona.Czarna, plansza));
            listaBierek.Add(new Hetman(new Punkt(4, 2), Strona.Czarna, plansza));

            listaBierek.Add(new Hetman(new Punkt(6, 6), Strona.Czarna, plansza));
            listaBierek.Add(new Hetman(new Punkt(2, 2), Strona.Czarna, plansza));
            listaBierek.Add(new Hetman(new Punkt(6, 2), Strona.Czarna, plansza));
            listaBierek.Add(new Hetman(new Punkt(2, 6), Strona.Czarna, plansza));

            listaBierek.Add(new Krol(new Punkt(3, 0), Strona.Biała, plansza));
            listaBierek.Add(new Krol(new Punkt(3, 7), Strona.Czarna, plansza));

            //sprawdzanie poprawnosci danych
            if (x == 4 && y > 6)
            {
                Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
            }
            else if (x == 4 && y < 2)
            {
                Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
            }
            else if (y == 4 && x > 6)
            {
                Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
            }
            else if (y == 4 && x < 2)
            {
                Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
            }
            else if (x > 6 && y > 6)
            {
                Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
            }
            else if (x < 2 && y < 2)
            {
                Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
            }
            else if (x > 6 && y < 2)
            {
                Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
            }
            else if (x < 2 && y > 6)
            {
                Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
            }
            else
            {
                Assert.IsTrue(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
            }
        }
Example #5
0
        public void HorVerQTest_Czy_zostaly_dodane_prawidlowe_liczby_do_kolejki_xy()
        {
            bool    actual = true;
            int     a      = 1;
            Plansza target = new Plansza();

            target.HorVerQ(2, 5);

            for (int j = 0; j < 9; j++)
            {
                if (target.xy.Peek() != target.sud[j, 5])
                {
                    actual = false;
                }
                target.xy.Enqueue(target.xy.Peek());
                target.xy.Dequeue();
                if (target.xy.Peek() != target.sud[2, j])
                {
                    actual = false;
                }
                target.xy.Enqueue(target.xy.Peek());
                target.xy.Dequeue();
            }
            Assert.IsTrue(actual);
        }
Example #6
0
        static void Main(string[] args)
        {
            Console.WriteLine("Szachownica");


            Plansza board = Plansza.Instance;  // Wywoływanie Planszy


            Figure p = FigureFactory.CreateFigure(FigureType.Wieza, Colors.Czarny, new Pozycja('B', 2)); // Zastosowanie Metody Fugite factory.Nazwa(Właściwosci wczesniej nadane)

            board[p, new Pozycja('D', 2)] = p.ShortName();

            Figure q = FigureFactory.CreateFigure(FigureType.Krolowa, Colors.Biały);

            board[q, new Pozycja('A', 7)] = q.ShortName();

            board.PrintBoard();


            Console.WriteLine("Figury na planszy:");
            foreach (string s in board)
            {
                Console.WriteLine(s);
            }

            int figuresOnBoard = board.FigureCount();

            Console.WriteLine("Liczba figur na planszy " + figuresOnBoard);



            Console.ReadKey();
        }
        public static void Rysuj(Plansza plansza)
        {
            var wysokosc       = plansza.WszystkiePola.Count;
            var firstOrDefault = plansza.WszystkiePola.FirstOrDefault();

            if (firstOrDefault == null)
            {
                return;
            }

            var szerokosc = firstOrDefault.Count;

            for (var i = 0; i < szerokosc + 2; i++)
            {
                Console.Write('-');
            }
            Console.WriteLine();

            for (var i = 0; i < wysokosc; i++)
            {
                Console.Write('|');
                for (var j = 0; j < szerokosc; j++)
                {
                    Console.Write(plansza.WszystkiePola[i][j].Znak);
                }
                Console.Write('|');
                Console.WriteLine();
            }

            for (var i = 0; i < szerokosc + 2; i++)
            {
                Console.Write('-');
            }
            Console.WriteLine();
        }
Example #8
0
 public WatekGracza(TcpClient k, int id, Plansza p)
 {
     plansza = p;
     idKlienta = id;
     klient = k;
     stream = klient.GetStream();
     mutex = new Mutex();
 }
Example #9
0
 public Move MakeMove(Plansza p, int gracz)
 {
     List<Move> moves = p.GenerateAllMoves(gracz);
     Random r = new Random(DateTime.Now.Second);
     if (moves.Count == 0)
         return null;
     return moves[r.Next(moves.Count)];
 }
Example #10
0
        public static void MinmaxTest(IPlayer white, IPlayer black)
        {
            int wynik = 0, wht = 0, draw = 0, blc = 0, total = 0;
            int size = 100;
            Move m;

            for (int i = 0; i < size; i++)
            {
                //                int now = DateTime.Now.Second;
                bool kto = true;
                Plansza p = new Plansza();
                p.rozpoczecie();
                wynik = 0;
                while ((wynik = p.GameEnded()) == 2)
                {
                    if (kto)
                    {
                        m = white.MakeMove(p, 1);
                        if (m == null)
                        {
                            wynik = 1;
                            break;
                        }
                    }
                    else
                    {
                        m = black.MakeMove(p, 2);
                        if (m == null)
                        {
                            wynik = -1;
                            break;
                        }
                    }
                    p.ExecuteMove(m);
                    kto = !kto;
                }
                switch (wynik)
                {
                    case -1:
                        wht++;
                        break;
                    case 0:
                        draw++;
                        break;
                    case 1:
                        blc++;
                        break;
                    default:
                        break;
                }
                //              Console.WriteLine(wynik + "   \t" + (DateTime.Now.Second-now) + " sec.");
                total++;
            }
            Console.WriteLine(white.MyName() + ":\t" + wht);// + "," + Math.Round(((double)wht/(double)total * 100.0), 2));
            Console.WriteLine("remis:\t" + draw);
            Console.WriteLine(black.MyName() + ":\t" + blc);// + "," + Math.Round(((double)blc / (double)total * 100.0), 2));
            Console.WriteLine();
        }
Example #11
0
        public static void Main(string[] args)
        {
            Inicjalizowanie.Pobierz();
            var plansza = new Plansza(Inicjalizowanie.Dane.X, Inicjalizowanie.Dane.Y);

            Rysowanie.Rysuj(plansza);

            Console.ReadKey();
        }
Example #12
0
        public static void TestFunction(int size, IPlayer white, IPlayer black)
        {
            StreamWriter sw = new StreamWriter("final_test.csv", true, System.Text.Encoding.UTF8);
            int wynik = 0, wht = 0, draw = 0, blc = 0, total = 0;
            Move m;

            for (int i = 0; i < size; i++)
            {
            //                int now = DateTime.Now.Second;
                bool kto = true;
                Plansza p = new Plansza();
                p.rozpoczecie();
                wynik = 0;
                while ((wynik = p.GameEnded()) == 2)
                {
                    if (kto)
                    {
                        m = white.MakeMove(p, 1);
                        if (m == null)
                        {
                            wynik = 1;
                            break;
                        }
                    }
                    else
                    {
                        m = black.MakeMove(p, 2);
                        if (m == null)
                        {
                            wynik = -1;
                            break;
                        }
                    }
                    p.ExecuteMove(m);
                    kto = !kto;
                }
                switch (wynik)
                {
                    case -1:
                        wht++;
                        break;
                    case 0:
                        draw++;
                        break;
                    case 1:
                        blc++;
                        break;
                    default:
                        break;
                }
              //              Console.WriteLine(wynik + "   \t" + (DateTime.Now.Second-now) + " sec.");
                total++;
            }
            sw.WriteLine(white.MyName() + "," + black.MyName() + "," + (double)wht / (double)total * 100.0 + "," + (double)draw / (double)total * 100.0 + "," + (double)blc / (double)total * 100.0 + "," + total);
            sw.Close();
        }
Example #13
0
        public void Prepare(Plansza plansza, MainForm forma)
        {
            this.plansza = plansza;
            this.main = forma;

            //computer1 = new NeuralNetwork("td1");
               // computer2 = new MinMaxCheckers(2);
            //computer2 = new NeuralNetwork("ll-black89.ntw");
            //MessageBox.Show("Biały: " + computer1.MyName());
            //    MessageBox.Show("Czarny: " + computer2.MyName());
        }
Example #14
0
        public void TestRuchowKrolaNiemozliwychDoWykonania(int x, int y)
        {
            //tworzenie danych
            List <Bierka> listaBierek = new List <Bierka>();
            Plansza       plansza     = new Plansza(null, Wygrana, listaBierek);

            //dodawanie bierek na stol
            listaBierek.Add(new Krol(new Punkt(4, 4), Strona.Biała, plansza));
            listaBierek.Add(new Krol(new Punkt(3, 7), Strona.Czarna, plansza));
            plansza.TestRuchow();
            //sprawdzanie poprawnosci danych
            Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
        }
Example #15
0
        public void TestKonstruktora()
        {
            plansza = new Plansza();

            Assert.AreEqual(Pole.Puste, plansza.GetPole(0));
            Assert.AreEqual(Pole.Puste, plansza.GetPole(1));
            Assert.AreEqual(Pole.Puste, plansza.GetPole(2));
            Assert.AreEqual(Pole.Puste, plansza.GetPole(3));
            Assert.AreEqual(Pole.Puste, plansza.GetPole(4));
            Assert.AreEqual(Pole.Puste, plansza.GetPole(5));
            Assert.AreEqual(Pole.Puste, plansza.GetPole(6));
            Assert.AreEqual(Pole.Puste, plansza.GetPole(7));
            Assert.AreEqual(Pole.Puste, plansza.GetPole(8));
        }
Example #16
0
        public void TestOgraniczeniaRuchowKrolaWmomencieWejsciaPodMata(int x, int y)
        {
            //tworzenie danych
            List <Bierka> listaBierek = new List <Bierka>();
            Plansza       plansza     = new Plansza(null, null, listaBierek);

            //dodawanie bierek na stol
            listaBierek.Add(new Krol(new Punkt(4, 4), Strona.Biała, plansza));
            listaBierek.Add(new Hetman(new Punkt(5, 1), Strona.Czarna, plansza));
            listaBierek.Add(new Krol(new Punkt(0, 0), Strona.Czarna, plansza));

            //sprawdzanie poprawnosci danych
            Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
        }
Example #17
0
        public void TestRuchowSkoczka(int x, int y)
        {
            //tworzenie danych
            List <Bierka> listaBierek = new List <Bierka>();
            Plansza       plansza     = new Plansza(null, null, listaBierek);

            //dodawanie bierek na stol
            listaBierek.Add(new Skoczek(new Punkt(4, 4), Strona.Biała, plansza));
            listaBierek.Add(new Krol(new Punkt(3, 0), Strona.Biała, plansza));
            listaBierek.Add(new Krol(new Punkt(3, 7), Strona.Czarna, plansza));

            //sprawdzanie poprawnosci danych
            Assert.IsTrue(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
        }
Example #18
0
        public void TestRuchowKrolaOgraniczonegoInnymiBierkamiInnegoKoloru(int x, int y)
        {
            //tworzenie danych
            List <Bierka> listaBierek = new List <Bierka>();
            Plansza       plansza     = new Plansza(null, Wygrana, listaBierek);

            //dodawanie bierek na stol
            listaBierek.Add(new Krol(new Punkt(4, 4), Strona.Biała, plansza));
            listaBierek.Add(new Hetman(new Punkt(x, y), Strona.Czarna, plansza));
            listaBierek.Add(new Krol(new Punkt(0, 0), Strona.Czarna, plansza));

            //sprawdzanie poprawnosci danych
            Assert.IsTrue(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
        }
Example #19
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);
        }
Example #20
0
        public void TestZbijaniaBierek(int x, int y)
        {
            //tworzenie danych
            List <Bierka> listaBierek = new List <Bierka>();
            Plansza       plansza     = new Plansza(null, null, listaBierek);

            //dodawanie bierek na stol
            listaBierek.Add(new Krol(new Punkt(0, 0), Strona.Biała, plansza));
            listaBierek.Add(new Krol(new Punkt(7, 7), Strona.Czarna, plansza));
            listaBierek.Add(new Hetman(new Punkt(4, 4), Strona.Biała, plansza));
            listaBierek.Add(new Pionek(new Punkt(x, y), Strona.Czarna, plansza));

            //sprawdzanie poprawnosci danych
            Assert.IsTrue(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
            Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(x, y), new Punkt(x, y) - new Punkt(x, y + 1)));
        }
Example #21
0
        public void PlanszaTest_Czy_Wypelnione_w_uzupelnionej_tablicy_sudoku_Sa_Wartosci_od_1_do_9()
        {
            bool    actual = true;
            Plansza target = new Plansza();

            for (int i = 0; i < 9; i++)
            {
                for (int j = 0; j < 9; j++)
                {
                    if (target.tab[i, j] > 9 || target.tab[i, j] < 1)
                    {
                        actual = false;
                    }
                }
            }
            Assert.IsTrue(actual);
        }
Example #22
0
        public void TestWykonaniaBiciaWprzelocie()
        {
            //tworzenie danych
            List <Bierka> listaBierek = new List <Bierka>();
            Plansza       plansza     = new Plansza(null, Wygrana, listaBierek);

            //dodawanie bierek na stol
            listaBierek.Add(new Krol(new Punkt(0, 0), Strona.Biała, plansza));
            listaBierek.Add(new Krol(new Punkt(7, 7), Strona.Czarna, plansza));
            listaBierek.Add(new Pionek(new Punkt(3, 4), Strona.Czarna, plansza));
            listaBierek.Add(new Pionek(new Punkt(4, 6), Strona.Biała, plansza));
            plansza.TestRuchow();
            //sprawdzanie poprawnosci danych
            Assert.IsTrue(plansza.SprobujWykonacRuch(new Punkt(4, 6), new Punkt(4, 4)));
            Assert.IsTrue(plansza.BierkaNaPozycji(new Punkt(3, 4), out _));
            Assert.IsTrue(plansza.SprobujWykonacRuch(new Punkt(3, 4), new Punkt(3, 5)));
        }
Example #23
0
        public void DeleteTest_Czy_została_usunieta_odpowiednia_ilosc_pol_55_level_medium()
        {
            int     ile    = 0;
            int     level  = 55;
            Plansza target = new Plansza();

            target.Delete(level);
            for (int i = 0; i < 9; i++)
            {
                for (int j = 0; j < 9; j++)
                {
                    if (target.sud[i, j] == 0)
                    {
                        ile++;
                    }
                }
            }
            Assert.AreEqual(level, ile);
        }
Example #24
0
        public void TestRuchowSkoczkaZasloniecieKrola(int x, int y)
        {
            //tworzenie danych
            List <Bierka> listaBierek = new List <Bierka>();
            Plansza       plansza     = new Plansza(null, Wygrana, listaBierek);

            //dodawanie bierek na stol
            listaBierek.Add(new Skoczek(new Punkt(4, 4), Strona.Biała, plansza));
            listaBierek.Add(new Hetman(new Punkt(2, 7), Strona.Czarna, plansza));
            listaBierek.Add(new Krol(new Punkt(2, 0), Strona.Biała, plansza));
            listaBierek.Add(new Krol(new Punkt(3, 7), Strona.Czarna, plansza));
            plansza.TestRuchow();
            //sprawdzanie poprawnosci danych
            if (x == 2)
            {
                Assert.IsTrue(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
            }
            else
            {
                Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
            }
        }
Example #25
0
        public void TestRuchowSkoczkaOgraniczonegoInnymiBierkamiTegoSamegoKoloru(int x, int y)
        {
            //tworzenie danych
            List <Bierka> listaBierek = new List <Bierka>();
            Plansza       plansza     = new Plansza(null, null, listaBierek);

            //dodawanie bierek na stol
            listaBierek.Add(new Skoczek(new Punkt(4, 4), Strona.Biała, plansza));
            listaBierek.Add(new Skoczek(new Punkt(2, 3), Strona.Biała, plansza));
            listaBierek.Add(new Skoczek(new Punkt(2, 5), Strona.Biała, plansza));
            listaBierek.Add(new Skoczek(new Punkt(3, 2), Strona.Biała, plansza));
            listaBierek.Add(new Skoczek(new Punkt(3, 6), Strona.Biała, plansza));
            listaBierek.Add(new Skoczek(new Punkt(5, 2), Strona.Biała, plansza));
            listaBierek.Add(new Skoczek(new Punkt(5, 6), Strona.Biała, plansza));
            listaBierek.Add(new Skoczek(new Punkt(6, 3), Strona.Biała, plansza));
            listaBierek.Add(new Skoczek(new Punkt(6, 5), Strona.Biała, plansza));
            listaBierek.Add(new Krol(new Punkt(3, 0), Strona.Biała, plansza));
            listaBierek.Add(new Krol(new Punkt(3, 7), Strona.Czarna, plansza));

            //sprawdzanie poprawnosci danych
            Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 4), new Punkt(x, y)));
        }
Example #26
0
        public void TestBlokadyKrotkiejRoszady()
        {
            //tworzenie danych
            List <Bierka> listaBierek = new List <Bierka>();
            Plansza       plansza     = new Plansza(null, Wygrana, listaBierek);

            //dodawanie bierek na stol
            listaBierek.Add(new Wieza(new Punkt(0, 0), Strona.Czarna, plansza));
            listaBierek.Add(new Wieza(new Punkt(7, 0), Strona.Czarna, plansza));
            listaBierek.Add(new Wieza(new Punkt(0, 7), Strona.Biała, plansza));
            listaBierek.Add(new Wieza(new Punkt(7, 7), Strona.Biała, plansza));
            listaBierek.Add(new Krol(new Punkt(4, 0), Strona.Czarna, plansza));
            listaBierek.Add(new Krol(new Punkt(4, 7), Strona.Biała, plansza));

            listaBierek.Add(new Wieza(new Punkt(5, 4), Strona.Czarna, plansza));
            listaBierek.Add(new Wieza(new Punkt(6, 4), Strona.Biała, plansza));

            plansza.TestRuchow();
            //sprawdzanie poprawnosci danych
            Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 7), new Punkt(6, 7)));
            Assert.IsTrue(plansza.SprobujWykonacRuch(new Punkt(4, 7), new Punkt(3, 7)));
            Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(4, 0), new Punkt(6, 0)));
        }
Example #27
0
        public void TestRuchowGoncaOgraniczonegoInnymiBierkamiInnegoKoloru(int x, int y)
        {
            //tworzenie danych
            List <Bierka> listaBierek = new List <Bierka>();
            Plansza       plansza     = new Plansza(null, null, listaBierek);

            //dodawanie bierek na stol
            listaBierek.Add(new Goniec(new Punkt(3, 3), Strona.Bia³a, plansza));
            listaBierek.Add(new Goniec(new Punkt(1, 1), Strona.Czarna, plansza));
            listaBierek.Add(new Goniec(new Punkt(6, 6), Strona.Czarna, plansza));
            listaBierek.Add(new Goniec(new Punkt(1, 5), Strona.Czarna, plansza));
            listaBierek.Add(new Goniec(new Punkt(5, 1), Strona.Czarna, plansza));
            listaBierek.Add(new Krol(new Punkt(3, 0), Strona.Bia³a, plansza));
            listaBierek.Add(new Krol(new Punkt(3, 7), Strona.Czarna, plansza));

            //sprawdzanie poprawnosci danych
            if (x < 1 && y < 1)
            {
                Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(3, 3), new Punkt(x, y)));
            }
            else if (x > 6 && y > 6)
            {
                Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(3, 3), new Punkt(x, y)));
            }
            else if (x < 1 && y > 5)
            {
                Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(3, 3), new Punkt(x, y)));
            }
            else if (x > 5 && y < 1)
            {
                Assert.IsFalse(plansza.SprobujWykonacRuch(new Punkt(3, 3), new Punkt(x, y)));
            }
            else
            {
                Assert.IsTrue(plansza.SprobujWykonacRuch(new Punkt(3, 3), new Punkt(x, y)));
            }
        }
Example #28
0
        public void Block3x3QTest_Czy_zostaly_dodane_prawidlowe_liczby_do_kolejki_blok()
        {
            bool    actual = true;
            Plansza target = new Plansza();

            target.Block3x3Q(2, 5);

            int a = 2 - (2 % 3);
            int b = 5 - (5 % 3);

            for (int i = a; i <= a + 2; i++)
            {
                for (int j = b; j <= b + 2; j++)
                {
                    if (target.blok.Peek() != target.sud[i, j])
                    {
                        actual = false;
                    }
                    target.blok.Enqueue(target.blok.Peek());
                    target.blok.Dequeue();
                }
            }
            Assert.IsTrue(actual);
        }
Example #29
0
        public void RandomTest_Czy_Metoda_Random_w_planszy_losuje_odpowiednie_liczby()
        {
            Plansza target = new Plansza();

            Assert.IsTrue(target.Random() >= 1 && target.Random() <= 9);
        }
Example #30
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();
        }
Example #31
0
File: Gra.cs Project: kitpz2/PaCa
 void watekStart(Object k)
 {
     TcpClient klient = (TcpClient)k;
     string polecenie = PoleceniaSieciowe.odbierzPolecenie(klient.GetStream());
     Polecenia sparsowanePolecenie = null;
     try
     {
         sparsowanePolecenie = Parser.parsuj(polecenie);
     }
     catch (Wyjatki.BlednePolecenie)
     {
         PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("NO", KodyBledu.blednePolecenie));
         return;
     }
     catch (Exception)
     {
         PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("NO", KodyBledu.nieoczekiwanyBlad));
         return;
     }
     if (sparsowanePolecenie.Polecenie == "CRE")
     {
         if (sparsowanePolecenie.RozmiarPlanszy.x < 10 || sparsowanePolecenie.RozmiarPlanszy.y < 10)
         {
             PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("NO", KodyBledu.blednyRozmiarPlanszy));
             return;
         }
         if (sparsowanePolecenie.MaksymalnaIloscGraczy > (int)(sparsowanePolecenie.RozmiarPlanszy.x * sparsowanePolecenie.RozmiarPlanszy.y / 50))
         {
             PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("NO", KodyBledu.zaDuzoGraczyNaPlansze));
             return;
         }
         if (sparsowanePolecenie.MaksymalnaIloscGraczy < 2)
         {
             PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("NO", KodyBledu.zaMaloGraczy));
             return;
         }
         if (sparsowanePolecenie.Tryb == Tryby.deathmatch)
             if (sparsowanePolecenie.PktDoZdobycia < 2 * 30 * sparsowanePolecenie.MaksymalnaIloscGraczy)
             {
                 PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("NO", KodyBledu.zaMaloPunktow));
                 return;
             }
         Plansza plansza = new Plansza(sparsowanePolecenie);
         try
         {
             gry.Add(sparsowanePolecenie.NazwaGry, plansza);
         }
         catch (ArgumentException)
         {
             PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("NO", KodyBledu.niemozliweUtworzenieGry));
             return;
         }
         catch (Exception)
         {
             PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("NO", KodyBledu.nieoczekiwanyBlad));
             return;
         }
         WatekGracza nowyGracz = new WatekGracza(klient, id, plansza);
         plansza.dodajKlienta(new Thread(nowyGracz.start));
         PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("OK", id++, wersjaSerwera));
     }
     else if (sparsowanePolecenie.Polecenie == "CON")
     {
         Plansza plansza = null;
         plansza = (Plansza)gry[sparsowanePolecenie.NazwaGry];
         if (plansza == null)
         {
             PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("NO", KodyBledu.brakGry));
             return;
         }
         WatekGracza nowyGracz = new WatekGracza(klient, id, plansza);
         plansza.dodajKlienta(new Thread(nowyGracz.start));
         PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("OK", id++, wersjaSerwera, plansza.rozmiarX, plansza.rozmiarY));
     }
     else if (sparsowanePolecenie.Polecenie == "LST")
     {
         List<listaPlansz> plansze = new List<listaPlansz>();
         foreach (Plansza p in gry.Values)
         {
             try
             {
                 if ((p.start == false && p.Tryb == Tryby.normalny) || (p.Tryb == Tryby.deathmatch))
                 {
                     plansze.Add(new listaPlansz(p.Nazwa, p.LiczbaGraczy, p.Tryb));
                 }
             }
             catch
             {
                 PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("NO", KodyBledu.nieoczekiwanyBlad));
                 return;
             }
         }
         PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("OK", plansze));
     }
     else
     {
         PoleceniaSieciowe.wyslijPolecenie(klient.GetStream(), new Polecenia("NO", KodyBledu.blednePolecenie));
         return;
     }
 }
Example #32
0
        private int alphabeta2(Plansza plansza, bool max, int alpha, int beta, int depth)
        {
            int wynik = plansza.GameEnded();
            if (wynik != 2)
            {
                if (wynik == -1)
                    return me == 1 ? 1000 : -1000;
                else if (wynik == 1)
                    return me == 2 ? 1000 : -1000;
                else
                    return max ? 10 : -10;

            }
            if (depth == 0 )
            {
                return -EvaluateGame(plansza);
            }
            int gracz = max ? me : me % 2 + 1;

            List<Move> moves = plansza.GenerateAllMoves(gracz);
            foreach (Move m in moves)
            {
                Plansza clone = plansza.Clone();
                clone.ExecuteMove(m);
                alpha = Math.Max(alpha, -alphabeta2(clone, !max, -beta, -alpha, depth - 1));
                if (alpha >= beta) return alpha;
                //int val = -alphabeta2(clone, !max, -beta, -alpha, depth - 1);
                //if (val >= beta) return val;
                //if (val > alpha) alpha = val;
            }
            return alpha;
        }
Example #33
0
        private void Inicjuj()
        {
            level = 1;
            points = 0;
            szybciej = false;
            gra = false;
            pauza = false;
            licznik.Interval = 1000;

            this.Plansza_tetris = new Plansza(18, 26);
            this.Plansza_tetris.Location = new System.Drawing.Point(150, 30);
            this.Plansza_tetris.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.Plansza_tetris.Name = "Plansza_tetris";
            this.Plansza_tetris.TabIndex = 0;
            this.Plansza_tetris.Paint += new PaintEventHandler(this.Plansza_Paint);
            this.Controls.Add(this.Plansza_tetris);

            this.next_klocek = new Plansza(4, 4);
            this.next_klocek.Location = new System.Drawing.Point(30, 30);
            this.next_klocek.Name = "next_klocek";
            this.next_klocek.TabIndex = 0;
            this.next_klocek.Paint += new PaintEventHandler(this.Plansza_Paint);
            next.Controls.Add(this.next_klocek);
        }
Example #34
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);
        }
Example #35
0
        //sprawdzam czy pionek na polu[x,y]
        public static int get_bicia(int x, int y, Plansza p)
        {
            int wynik = 0;

            if (p.pole[x, y] == 2)
            {//sasiadem jest pion gracza 1, gracz jest pionem
                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)
                    wynik = wynik + 1;

                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)
                    wynik = wynik + 2;

                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)
                    wynik = wynik + 4;

                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)
                    wynik = wynik + 8;
            }
            else if (p.pole[x, y] == 3)
            {//sasiadem jest pion gracza 2, gracz jest pionem
                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)
                    wynik = wynik + 1;

                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)
                    wynik = wynik + 2;

                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)
                    wynik = wynik + 4;

                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)
                    wynik = wynik + 8;
            }
            else if (p.pole[x, y] == 4)// damka gracza 1
            {//patrzenie w 4 kierunkach
                int i = 0; int j = 0;
                while (x + i > 1 && y + j > 1)
                {
                    if ((p.pole[x + i - 1, y + j - 1] == 3 || p.pole[x + i - 1, y + j - 1] == 5)
                        && p.pole[x + i - 2, y + j - 2] == 1)
                    {
                        wynik = wynik + 1;
                        break;
                    }
                    else if (p.pole[x + i - 1, y + j - 1] != 1)
                    {
                        break;
                    }
                    else
                    {
                        --i;
                        --j;
                    }
                }

                i = 0; j = 0;

                while (x + i < 6 && y + j > 1)
                {
                    if ((p.pole[x + i + 1, y + j - 1] == 3 || p.pole[x + i + 1, y + j - 1] == 5)
                        && p.pole[x + i + 2, y + j - 2] == 1)
                    {
                        wynik = wynik + 2;
                        break;
                    }
                    else if (p.pole[x + i + 1, y + j - 1] != 1)
                    {
                        break;
                    }
                    else
                    {
                        ++i;
                        --j;
                    }
                }

                i = 0; j = 0;

                while (x + i > 1 && y + j < 6)
                {
                    if ((p.pole[x + i - 1, y + j + 1] == 3 || p.pole[x + i - 1, y + j + 1] == 5)
                        && p.pole[x + i - 2, y + j + 2] == 1)
                    {
                        wynik = wynik + 4;
                        break;
                    }
                    else if (p.pole[x + i - 1, y + j + 1] != 1)
                    {
                        break;
                    }
                    else
                    {
                        --i;
                        ++j;
                    }
                }

                i = 0; j = 0;

                while (x + i < 6 && y + j < 6)
                {
                    if ((p.pole[x + i + 1, y + i + 1] == 3 || p.pole[x + i + 1, y + j + 1] == 5)
                        && p.pole[x + j + 2, y + j + 2] == 1)
                    {
                        wynik = wynik + 8;
                        break;
                    }
                    else if (p.pole[x + i + 1, y + j + 1] != 1)
                    {
                        break;
                    }
                    else
                    {
                        ++i;
                        ++j;
                    }
                }

            }
            else if (p.pole[x, y] == 5)
            {
                int i = 0; int j = 0;
                while (x + i > 1 && y + j > 1)
                {
                    if ((p.pole[x + i - 1, y + j - 1] == 2 || p.pole[x + i - 1, y + j - 1] == 4)
                        && p.pole[x + i - 2, y + j - 2] == 1)
                    {
                        wynik = wynik + 4;
                        break;
                    }
                    else if (p.pole[x + i - 1, y + j - 1] != 1)
                    {
                        break;
                    }
                    else
                    {
                        --i;
                        --j;
                    }
                }

                i = 0; j = 0;

                while (x + i < 6 && y + j > 1)
                {
                    if ((p.pole[x + i + 1, y + j - 1] == 2 || p.pole[x + i + 1, y + j - 1] == 4)
                        && p.pole[x + i + 2, y + j - 2] == 1)
                    {
                        wynik = wynik + 8;
                        break;
                    }
                    else if (p.pole[x + i + 1, y + j - 1] != 1)
                    {
                        break;
                    }
                    else
                    {
                        ++i;
                        --j;
                    }
                }

                i = 0; j = 0;

                while (x + i > 1 && y + j < 6)
                {
                    if ((p.pole[x + i - 1, y + j + 1] == 2 || p.pole[x + i - 1, y + j + 1] == 4)
                        && p.pole[x + i - 2, y + j + 2] == 1)
                    {
                        wynik = wynik + 1;
                        break;
                    }
                    else if (p.pole[x + i - 1, y + j + 1] != 1)
                    {
                        break;
                    }
                    else
                    {
                        --i;
                        ++j;
                    }
                }

                i = 0; j = 0;

                while (x + i < 6 && y + j < 6)
                {
                    if ((p.pole[x + i + 1, y + i + 1] == 2 || p.pole[x + i + 1, y + j + 1] == 4)
                        && p.pole[x + j + 2, y + j + 2] == 1)
                    {
                        wynik = wynik + 2;
                        break;
                    }
                    else if (p.pole[x + i + 1, y + j + 1] != 1)
                    {
                        break;
                    }
                    else
                    {
                        ++i;
                        ++j;
                    }
                }

            }

            //if (wynik != 0) przymus = true;

            return wynik;
        }
Example #36
0
        /*fun minimax(n: node, d: int, min: int, max: int): int =
           if leaf(n) or depth=0 return evaluate(n)
           if n is a max node
          v := min
          for each child of n
         v' := minimax (child,d-1,v,max)
         if v' > v, v:= v'
         if v > max return max
          return v
         */
        //HEURYSTYKA - przechodzi po calej planszy i zlicza jezeli na planszy jest twoj pionek to dodaje 1
        //a jak przeciwnika to odejmuje
        //private int EvaluateGame(Plansza plansza)
        //{
        // //   bool black = false, white = false;
        //    int res = 0;
        //    for (int i = 0; i < 8; i++)
        //    {
        //        for (int j = 0; j < 8; j++)
        //        {
        //            if (plansza[i, j] == 2)
        //            {
        //   //             white = true;
        //                res += 1;
        //                //   if(plansza.IsSafe(i,j, me))
        //                //       res += 1;
        //            }
        //            else if (plansza[i, j] == 4)
        //            {
        //     //           white = true;
        //                res += 1;
        //                //   if (plansza.IsSafe(i, j, me))
        //                //       res += 3;
        //            }
        //            else if (plansza[i, j] == 3)
        //            {
        //       //         black = true;
        //                res -= 1;
        //                //if (plansza.IsSafe(i, j, me%2+1))
        //                //    res -= 1;
        //            }
        //            else if (plansza[i, j] == 5)
        //            {
        //         //       black = true;
        //                res -= 1;
        //                //if (plansza.IsSafe(i, j, me))
        //                //    res -= 3;
        //            }
        //        }
        //    }/*
        //    if (black == false)
        //        res = -1000;
        //    else if (white == false)
        //        res = 1000;
        //    */
        //    if (me == 2)
        //    {
        //        if (maxDepth % 2 == 0)//jezeli jestem na ruchu swoim
        //            return -res;
        //        return res;
        //    }
        //    else
        //    {
        //        if (maxDepth % 2 == 1 )//przeciwnika
        //            return -res;
        //        return res;
        //    }
        //}
        private int EvaluateGame(Plansza plansza)
        {
            int sum = 0;
            for(int i=0; i < 8; i++)
                for (int j = 0; j < 8; j++)
                {
                    if (plansza[i, j] < 2) continue;
                    switch (plansza[i, j])
                    {
                        case 2:
                            sum += pionek;
                            break;
                        case 3:
                            sum -= pionek;
                            break;
                        case 4:
                            sum += damka;
                            break;
                        case 5:
                            sum -= damka;
                            break;
                    }
                    int min;
                    switch (plansza[i, j]%2)
                    {
                        case 1:
                            sum += Bicia.get_bicia(i, j, plansza)*bicie;
                            sum += levels[j/2];
                            if (i == 0 || i == 7 || j == 0 || j == 7)
                                sum += zones[0];
                            else if (i == 1 || i == 6 || j == 1 || j == 6)
                                sum += zones[1];
                            else
                                sum += zones[2];
                            if(i>0&&j>0&&i<7&&j<7)
                                sum += new[] {-1, 1}.SelectMany(x => new[] {-1, 1}.Select(y => new {up = j + x, left = i + y})).Sum(dir => plansza[dir.left, dir.up]);
                            min = plansza.Where(x => x.val%2 == 1).Max(x => x.y);
                            if (j <= min)
                                sum -= spalony;
                            break;
                        case 2:
                            sum -= Bicia.get_bicia(i, j, plansza)*bicie;
                            sum += levels[j / 2];
                            if (i == 0 || i == 7 || j == 0 || j == 7)
                                sum -= zones[0];
                            else if (i == 1 || i == 6 || j == 1 || j == 6)
                                sum -= zones[1];
                            else
                                sum -= zones[2];
                            if (i > 0 && j > 0 && i < 7 && j < 7)
                                sum -= new[] { -1, 1 }.SelectMany(x => new[] { -1, 1 }.Select(y => new { up = j + x, left = i + y })).Sum(dir => plansza[dir.left, dir.up]);
                            min = plansza.Where(x => x.val%2 == 1).Min(x => x.y);
                            if (j >= min)
                                sum -= spalony;
                            break;
                    }
                }

            if (me == 2)
            {
                if (maxDepth % 2 == 0)//jezeli jestem na ruchu swoim
                    return -sum;
                return sum;
            }
            else
            {
                if (maxDepth%2 == 1) //przeciwnika
                    return -sum;
                return sum;
            }
        }
Example #37
0
        /// <summary>
        /// sterowanie grą
        /// </summary>
        static void MainGry(Strona side, bool bot = true)
        {
            //inicjalizuje plansze
            plansza = new Plansza(PromocjaPionka, KoniecGry);
            gra     = true;
            KomputerowyPrzeciwnik komputerowyPrzeciwnik = new KomputerowyPrzeciwnik(plansza, 1);

            //rysowanie
            Console.Clear();
            RysujPlansze();
            //działanie
            while (gra)
            {
                if (bot && side == plansza.StronaGrajaca)
                {
                    komputerowyPrzeciwnik.WykonajRuch();
                    RysujPlansze();
                }
                switch (Console.ReadKey().Key)
                {
                case ConsoleKey.UpArrow:
                {
                    Punkt staraPozycja = kursorPozycja;
                    kursorPozycja = new Punkt(staraPozycja.X, staraPozycja.Y - 1);
                    if (!kursorPozycja.Pomiedzy(7))
                    {
                        kursorPozycja = staraPozycja;
                    }
                    RysujPole(staraPozycja);
                    RysujPole(kursorPozycja);
                    break;
                }

                case ConsoleKey.DownArrow:
                {
                    Punkt staraPozycja = kursorPozycja;
                    kursorPozycja = new Punkt(staraPozycja.X, staraPozycja.Y + 1);
                    if (!kursorPozycja.Pomiedzy(7))
                    {
                        kursorPozycja = staraPozycja;
                    }
                    RysujPole(staraPozycja);
                    RysujPole(kursorPozycja);
                    break;
                }

                case ConsoleKey.LeftArrow:
                {
                    Punkt staraPozycja = kursorPozycja;
                    kursorPozycja = new Punkt(staraPozycja.X - 1, staraPozycja.Y);
                    if (!kursorPozycja.Pomiedzy(7))
                    {
                        kursorPozycja = staraPozycja;
                    }
                    RysujPole(staraPozycja);
                    RysujPole(kursorPozycja);
                    break;
                }

                case ConsoleKey.RightArrow:
                {
                    Punkt staraPozycja = kursorPozycja;
                    kursorPozycja = new Punkt(staraPozycja.X + 1, staraPozycja.Y);
                    if (!kursorPozycja.Pomiedzy(7))
                    {
                        kursorPozycja = staraPozycja;
                    }
                    RysujPole(staraPozycja);
                    RysujPole(kursorPozycja);
                    break;
                }

                case ConsoleKey.Enter:
                    if (mozliweRuchy.Contains(kursorPozycja))
                    {
                        plansza.SprobujWykonacRuch(zaznaczenie, kursorPozycja);
                        zaznaczenie  = null;
                        mozliweRuchy = new List <Punkt>();
                        if (gra)
                        {
                            RysujPlansze();
                        }
                    }
                    else if (plansza.BierkaNaPozycji(kursorPozycja, out Bierka bierka))
                    {
                        if (bierka.Kolor == plansza.StronaGrajaca)
                        {
                            zaznaczenie  = kursorPozycja;
                            mozliweRuchy = bierka.PobMozliweRuchy;
                            RysujPlansze();
                        }
                    }
                    break;

                case ConsoleKey.Q:
                    Console.Clear();
                    return;
                }
                Console.CursorLeft = 0;
                Console.CursorTop  = 0;
            }
            Console.Clear();
        }
Example #38
0
 public void setP1(Plansza p1)
 {
     this.p1 = p1;
 }
Example #39
0
        public List<Plansza[]> Parse(int count, int krok, int rank)
        {
            bool stop = false;
            Plansza p = new Plansza();
            int pp = 200;
            int kkrok = 0;
            int nrListy = 0;
            int pionki = 0;
            while (true)
            {

                string s = ReadFileByLine();
                if (s == null) return plansze;
                while ( stop && !s.StartsWith("[Event"))

                { s = ReadFileByLine(); }

                stop = false;

                //if (plansze.Count > pp) {
                    //Console.WriteLine("{0}", plansze.Count);
                    //pp = pp + 500; }
                if (plansze.Count == count) break;

                if (s.StartsWith("[Event"))
                {
                    kkrok++;

                    p = new Plansza();
                    p.rozpoczecie();
                }
                else if (s.StartsWith("[Result"))
                {
                    s = s.Remove(0, 9);
                    if (s.StartsWith("1"))
                        p.wynik = 1;
                    else
                        p.wynik = -1;
                }
                else
                    if (s.StartsWith("[WhiteElo"))
                {
                    s = s.Remove(0, 11);
                    s = s.Remove(3);        //bylo 4
                    int r = int.Parse(s);
                    if (r < rank)
                    { stop = true;}// continue; }
                }
                else if (s.StartsWith("[BlackElo"))
                {
                    s = s.Remove(0, 11);
                    s = s.Remove(3);        //bylo 4
                    int r = int.Parse(s);
                    if (r < rank)
                    { stop = true; }// continue; }
                }
                else if (!s.StartsWith("["))
                {
                    //if (stop) continue;
                    plansze.Add(new Plansza[(int)((24 / krok) - 1)]);
                    pionki = 24;
                    StringBuilder sb = new StringBuilder();
                    string tmp;// = ReadFileByLine();
                    while ((tmp = ReadFileByLine()) != "")
                    {
                        sb.Append(tmp + " ");

                        //s.Insert(s.Length, tmp);

                        //while (!tmp.StartsWith(@"a-h"))
                        //    tmp = tmp.Remove(0, 1);
                        //if (tmp.
                    }
                    if (sb.ToString().Contains("{*}")) { stop = true; continue; }
                    Regex rgx = new Regex("[0-9][.] | [0-9][0-9][.]");
                    foreach (string str in rgx.Split(sb.ToString()))
                    {
                        string[] ss = str.Split(' ');
                        //if (ss[0] == "") ss.
                        //if (ss.Length != 4) continue;
                        for (int m = 0; m < ss.Length; m++)
                        {
                            if (ss[m] == "") continue;
                            if (ss[m][0] == '0' || ss[m][0] == '1')
                            { stop = true; break; }

                            int k = 0;
                            while (k + 2 < ss[m].Length && (ss[m][k + 2] == 'x' || ss[m][k + 2] == '-'))
                            {
                                char sdf = ss[m][k + 0];
                                int no = getNoFromLetter(sdf);
                                int no2 = int.Parse(ss[m].Substring(k + 1, 1)) - 1;
                                //p.pole[no, no2] = 1;
                                sdf = ss[m][k + 3];
                                int no3 = getNoFromLetter(sdf);
                                int no4 = int.Parse(ss[m].Substring(k + 4, 1)) - 1;
                                //if (m == 1) p.pole[no3, no4] = 3;
                                //else p.pole[no3, no4] = 2;
                                Move m1 = new Move(new Point(no, 7 - no2));
                                m1.Add(new Point(no3, 7 - no4));
                                p.ExecuteMove(m1); //break;
                                if (p.iloscPionkow() == pionki - krok)
                                {
                                    Plansza r = p.Clone();
                                    plansze[nrListy][24/krok-pionki/krok] = r;
                                    pionki = p.iloscPionkow();
                                    //kkrok = 0;
                                }
                                else if (p.iloscPionkow() < pionki - krok)
                                {
                                }
                                k = k + 3;
                            }
                            //if (kkrok == krok)
                            //{

                            //    Plansza r = p.Clone();
                            //    plansze[nrListy].Add(r); kkrok = 0;
                            //}
                            //return plansze;
                        }
                        if (stop) break;
                    }
                    if (stop)
                    { nrListy++; continue; }
                }
            }
            //plansze.RemoveAt(plansze.Count - 1);
            return plansze;
        }
Example #40
0
 public Move MinMaxMove(Plansza board, int gracz)
 {
     return MakeMove(board, gracz);
 }
Example #41
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);
        }