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)];
}
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)));
}
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);
}
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)));
}
}
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);
}
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();
}
public WatekGracza(TcpClient k, int id, Plansza p)
{
plansza = p;
idKlienta = id;
klient = k;
stream = klient.GetStream();
mutex = new Mutex();
}
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)];
}
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();
}
public static void Main(string[] args)
{
Inicjalizowanie.Pobierz();
var plansza = new Plansza(Inicjalizowanie.Dane.X, Inicjalizowanie.Dane.Y);
Rysowanie.Rysuj(plansza);
Console.ReadKey();
}
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();
}
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());
}
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)));
}
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));
}
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)));
}
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)));
}
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)));
}
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);
}
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)));
}
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);
}
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)));
}
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);
}
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)));
}
}
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)));
}
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)));
}
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)));
}
}
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);
}
public void RandomTest_Czy_Metoda_Random_w_planszy_losuje_odpowiednie_liczby()
{
Plansza target = new Plansza();
Assert.IsTrue(target.Random() >= 1 && target.Random() <= 9);
}
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();
}
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;
}
}
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;
}
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);
}
public void sprawdz_bicia(Gracz gracz, Plansza p, int x, int y)
{
zerowanie();
przymus = false;
this.pole[x, y] = get_bicia(x, y, p);
}
//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;
}
/*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;
}
}
/// <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();
}
public void setP1(Plansza p1)
{
this.p1 = p1;
}
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;
}
public Move MinMaxMove(Plansza board, int gracz)
{
return MakeMove(board, gracz);
}
/// <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);
}