Ejemplo n.º 1
0
 void ФигуруСдвинуть(int сдвиг)
 {
     lock (SyncRoot)
     {
         ФигуруСменить(Фигура?.СдвинутьВправо(сдвиг));
     }
 }
Ejemplo n.º 2
0
 void IИгра.ФигуруСбросить()
 {
     lock (SyncRoot)
     {
         while (ФигуруСменить(Фигура?.СдвинутьВниз()))
         {
             ;
         }
     }
 }
Ejemplo n.º 3
0
 public bool СменитьФигуру(Фигура стараяФигура, Фигура новаяФигура)
 {
     lock (SyncRoot)
     {
         МеняемФигуры(стараяФигура, новаяФигура);
         var успешно = ПроверитьСостояние();
         if (!успешно)
         {
             МеняемФигуры(новаяФигура, стараяФигура);
         }
         return(успешно);
     }
 }
Ejemplo n.º 4
0
 bool СоздатьНовуюФигуру()
 {
     lock (SyncRoot)
     {
         Фигура = ГенераторФигур.Получить(ИгровоеПоле.НачальнаяПозицияФигуры);
         while (!ИгровоеПоле.Содержит(Фигура))
         {
             Фигура = Фигура.СдвинутьВниз();
         }
         ИгровоеПоле.Добавить(Фигура);
         return(ИгровоеПоле.ПроверитьСостояние());
     }
 }
Ejemplo n.º 5
0
        bool ФигуруСменить(Фигура новаяФигура)
        {
            if (Фигура == null || !ИгровоеПоле.Содержит(новаяФигура))
            {
                return(false);
            }

            var успешно = ИгровоеПоле.СменитьФигуру(Фигура, новаяФигура);

            if (успешно)
            {
                Фигура = новаяФигура;
            }
            return(успешно);
        }
Ejemplo n.º 6
0
        void Учесть(Фигура фигура, ТипМодификации типМодификации)
        {
            if (фигура == null)
            {
                return;
            }
            var модификатор = (int)типМодификации;

            foreach (var точка in фигура.ПолучитьТочки())
            {
                if (Cодержит(точка))
                {
                    яды[точка.Y][точка.X] += модификатор;
                }
            }

            ПолеИзменилось?.Invoke(this, EventArgs.Empty);
        }
Ejemplo n.º 7
0
        bool ОпуститьФигуруВниз()
        {
            lock (SyncRoot)
            {
                var смещённаяФигура = Фигура.СдвинутьВниз();
                var успех           = ИгровоеПоле.Содержит(смещённаяФигура);
                if (!успех)
                {
                    return(false);
                }

                успех = ИгровоеПоле.СменитьФигуру(Фигура, смещённаяФигура);
                if (успех)
                {
                    Фигура = смещённаяФигура;
                }
                //#if DEBUG
                //				else
                //					System.Diagnostics.Debugger.Break();
                //#endif
                return(успех);
            }
        }
Ejemplo n.º 8
0
 void IИгра.ФигуруПовернуть()
 {
     if (Фигура == null)
     {
         return;
     }
     lock (SyncRoot)
     {
         var повёрнутаяФигура      = Фигура.Повернуть();
         var фигураСдвинутаяВлево  = повёрнутаяФигура.СдвинутьВлево();
         var фигураСдвинутаяВправо = повёрнутаяФигура.СдвинутьВправо();
         var фигураСдвинутаяВниз   = повёрнутаяФигура.СдвинутьВниз();
         var фигураСдвинутаяВниз2  = фигураСдвинутаяВниз.СдвинутьВниз();
         var возможныеФигуры       = new[]
         {
             повёрнутаяФигура,
             фигураСдвинутаяВлево,
             фигураСдвинутаяВправо,
             фигураСдвинутаяВниз,
             фигураСдвинутаяВниз2,
         };
         возможныеФигуры.FirstOrDefault(фигура => ФигуруСменить(фигура));
     }
 }
Ejemplo n.º 9
0
 public bool Содержит(Фигура фигура) => фигура.ПолучитьТочки().All(Cодержит);
Ejemplo n.º 10
0
 ИгровоеПоле Вычесть(Фигура фигура)
 {
     Учесть(фигура, ТипМодификации.Вычесть);
     return(this);
 }
Ejemplo n.º 11
0
 public ИгровоеПоле Добавить(Фигура фигура)
 {
     Учесть(фигура, ТипМодификации.Добавить);
     return(this);
 }
Ejemplo n.º 12
0
 void МеняемФигуры(Фигура стараяФигура, Фигура новаяФигура)
 {
     Вычесть(стараяФигура);
     Добавить(новаяФигура);
 }
Ejemplo n.º 13
0
        private void pictureBox3_Click(object sender, EventArgs e) // ход вперед
        {
            if (ходБелых)
            {
                ход++;
                // извлекаем из строки ход
                //1.e4 e5 -> e4
                string move = СписокХодов[ход - 1].Substring(СписокХодов[ход - 1].IndexOf('.') + 1, СписокХодов[ход - 1].IndexOf(' ') - СписокХодов[ход - 1].IndexOf('.') - 1);
                // рашрифровуем ход и ходим (меняем в массиве фигур положение)
                // N = knight
                // B = bishop
                // R = rock
                // Q = queen
                // K = king
                // _ = pawn
                label1.Text = СписокХодов[ход - 1];

                bool взятиеФигуры = false;
                if (move[1] == 'x')
                {
                    взятиеФигуры = true;
                    move         = move.Remove(1, 1);
                }

                if (move[0] == 'N') // Nf3 --- Nef3 N1g5 ---
                {
                    foreach (Фигура ф in БелыеФигуры)
                    {
                        if (
                            ф.тип == "конь"
                            &&
                            (
                                (Math.Abs(ф.x - toDigit(move[1])) == 1 && Math.Abs(ф.y - (move[2] - 48)) == 2)
                                ||
                                (Math.Abs(ф.x - toDigit(move[1])) == 2 && Math.Abs(ф.y - (move[2] - 48)) == 1)
                            )
                            )
                        {
                            ф.x = toDigit(move[1]);
                            ф.y = move[2] - 48;
                            if (взятиеФигуры == true)
                            {
                                Фигура фигураНаУдаление = new Фигура();
                                foreach (Фигура ф1 in ЧерныеФигуры)
                                {
                                    if (ф1.x == ф.x && ф1.y == ф.y)
                                    {
                                        фигураНаУдаление = ф1;
                                        break;
                                    }
                                }
                                ЧерныеФигуры.Remove(фигураНаУдаление);
                            }
                            break;
                        }
                    }
                }
                if (move[0] == 'R') // Rf3 --- Ref3 R1g5 ---
                {
                    foreach (Фигура ф in БелыеФигуры)
                    {
                        if (
                            ф.тип == "тура"
                            &&
                            (
                                (ф.x == toDigit(move[1]) && свободно(ф.x, ф.y, toDigit(move[1]), move[2] - 48))
                                ||
                                (ф.y == move[2] && свободно(ф.x, ф.y, toDigit(move[1]), move[2] - 48))

                            )
                            )
                        {
                            ф.x = toDigit(move[1]);
                            ф.y = move[2] - 48;
                            if (взятиеФигуры == true)
                            {
                                Фигура фигураНаУдаление = new Фигура();
                                foreach (Фигура ф1 in ЧерныеФигуры)
                                {
                                    if (ф1.x == ф.x && ф1.y == ф.y)
                                    {
                                        фигураНаУдаление = ф1;
                                        break;
                                    }
                                }
                                ЧерныеФигуры.Remove(фигураНаУдаление);
                            }
                            break;
                        }
                    }
                }
                if (move[0] == 'B') // Bf3 --- Bef4 B1g5 ---
                {
                    foreach (Фигура ф in БелыеФигуры)
                    {
                        if (
                            ф.тип == "слон"
                            &&
                            (
                                (Math.Abs(ф.x - toDigit(move[1])) == Math.Abs(ф.y - (move[2] - 48))) && свободно(ф.x, ф.y, toDigit(move[1]), move[2] - 48)

                            )
                            )
                        {
                            ф.x = toDigit(move[1]);
                            ф.y = move[2] - 48;
                            if (взятиеФигуры == true)
                            {
                                Фигура фигураНаУдаление = new Фигура();
                                foreach (Фигура ф1 in ЧерныеФигуры)
                                {
                                    if (ф1.x == ф.x && ф1.y == ф.y)
                                    {
                                        фигураНаУдаление = ф1;
                                        break;
                                    }
                                }
                                ЧерныеФигуры.Remove(фигураНаУдаление);
                            }
                            break;
                        }
                    }
                }
                if (move[0] == 'Q') // Qf3
                {
                    foreach (Фигура ф in БелыеФигуры)
                    {
                        if (
                            ф.тип == "ферзь"
                            )
                        {
                            ф.x = toDigit(move[1]);
                            ф.y = move[2] - 48;
                            if (взятиеФигуры == true)
                            {
                                Фигура фигураНаУдаление = new Фигура();
                                foreach (Фигура ф1 in ЧерныеФигуры)
                                {
                                    if (ф1.x == ф.x && ф1.y == ф.y)
                                    {
                                        фигураНаУдаление = ф1;
                                        break;
                                    }
                                }
                                ЧерныеФигуры.Remove(фигураНаУдаление);
                            }
                            break;
                        }
                    }
                }
                if (move[0] == 'K') // Kf3
                {
                    foreach (Фигура ф in БелыеФигуры)
                    {
                        if (
                            ф.тип == "король"
                            )
                        {
                            ф.x = toDigit(move[1]);
                            ф.y = move[2] - 48;
                            if (взятиеФигуры == true)
                            {
                                Фигура фигураНаУдаление = new Фигура();
                                foreach (Фигура ф1 in ЧерныеФигуры)
                                {
                                    if (ф1.x == ф.x && ф1.y == ф.y)
                                    {
                                        фигураНаУдаление = ф1;
                                        break;
                                    }
                                }
                                ЧерныеФигуры.Remove(фигураНаУдаление);
                            }
                            break;
                        }
                    }
                }

                if (move[0] == 'a' || move[0] == 'b' || move[0] == 'c' || move[0] == 'd' || move[0] == 'e' || move[0] == 'f' || move[0] == 'g' || move[0] == 'h') //e2 -> e4
                {
                    if (взятиеФигуры == false)                                                                                                                    // e4
                    {
                        bool s = false;
                        foreach (Фигура ф in БелыеФигуры)
                        {
                            if (
                                ф.тип == "пешка" &&
                                ф.x == toDigit(move[0]) &&
                                ф.y == (move[1] - 48) - 1
                                )
                            {
                                ф.x = toDigit(move[0]);
                                ф.y = move[1] - 48;
                                s   = true;
                                break;
                            }
                        }
                        if (s == false)
                        {
                            foreach (Фигура ф in БелыеФигуры)
                            {
                                if (
                                    ф.тип == "пешка" &&
                                    ф.x == toDigit(move[0]) &&
                                    ф.y == (move[1] - 48) - 2
                                    )
                                {
                                    ф.x = toDigit(move[0]);
                                    ф.y = move[1] - 48;
                                    break;
                                }
                            }
                        }
                    }
                    if (взятиеФигуры == true) // de4
                    {
                        foreach (Фигура ф in БелыеФигуры)
                        {
                            if (
                                ф.тип == "пешка" &&
                                ф.x == toDigit(move[0]) &&
                                ф.y == (move[2] - 48) - 1
                                )
                            {
                                ф.x = toDigit(move[1]);
                                ф.y = move[2] - 48;
                                Фигура фигураНаУдаление = new Фигура();
                                foreach (Фигура ф1 in ЧерныеФигуры)
                                {
                                    if (ф1.x == ф.x && ф1.y == ф.y)
                                    {
                                        фигураНаУдаление = ф1;
                                        break;
                                    }
                                }
                                ЧерныеФигуры.Remove(фигураНаУдаление);
                                break;
                            }
                        }
                    }
                }
                if (move == "O-O")
                {
                    foreach (Фигура ф in БелыеФигуры)
                    {
                        if (ф.тип == "король")
                        {
                            ф.x = 7;
                            ф.y = 1;
                            break;
                        }
                    }
                    foreach (Фигура ф in БелыеФигуры)
                    {
                        if (ф.тип == "тура" && ф.x == 8)
                        {
                            ф.x = 6;
                            ф.y = 1;
                        }
                    }
                }
                if (move == "O-O-O")
                {
                    foreach (Фигура ф in БелыеФигуры)
                    {
                        if (ф.тип == "король")
                        {
                            ф.x = 3;
                            ф.y = 1;
                            break;
                        }
                    }
                    foreach (Фигура ф in БелыеФигуры)
                    {
                        if (ф.тип == "тура" && ф.x == 1)
                        {
                            ф.x = 4;
                            ф.y = 1;
                        }
                    }
                }

                // вызываем перерисовку
                Invalidate();

                // передаем ход противоположной стороне
                ходБелых = false;
            }

            else
            {
                // извлекаем из строки ход
                //1.e4 e5 -> e4
                string move = СписокХодов[ход - 1].Substring(СписокХодов[ход - 1].IndexOf(' ') + 1);
                // рашрифровуем ход и ходим (меняем в массиве фигур положение)
                // N = knight
                // B = bishop
                // R = rock
                // Q = queen
                // K = king
                // _ = pawn
                label1.Text = СписокХодов[ход - 1];
                bool взятиеФигуры = false;
                if (move[1] == 'x')
                {
                    взятиеФигуры = true;
                    move         = move.Remove(1, 1);
                }
                if (move[0] == 'N') // Nf3 --- Nef3 N1g5 ---
                {
                    foreach (Фигура ф in ЧерныеФигуры)
                    {
                        if (
                            ф.тип == "конь"
                            &&
                            (
                                (Math.Abs(ф.x - toDigit(move[1])) == 1 && Math.Abs(ф.y - (move[2] - 48)) == 2)
                                ||
                                (Math.Abs(ф.x - toDigit(move[1])) == 2 && Math.Abs(ф.y - (move[2] - 48)) == 1)
                            )
                            )
                        {
                            ф.x = toDigit(move[1]);
                            ф.y = move[2] - 48;
                            if (взятиеФигуры == true)
                            {
                                Фигура фигураНаУдаление = new Фигура();
                                foreach (Фигура ф1 in БелыеФигуры)
                                {
                                    if (ф1.x == ф.x && ф1.y == ф.y)
                                    {
                                        фигураНаУдаление = ф1;
                                        break;
                                    }
                                }
                                БелыеФигуры.Remove(фигураНаУдаление);
                            }
                            break;
                        }
                    }
                }
                if (move[0] == 'R') // Rf3 --- Ref3 R1g5 ---
                {
                    foreach (Фигура ф in ЧерныеФигуры)
                    {
                        if (
                            ф.тип == "тура"
                            &&
                            (
                                (ф.x == toDigit(move[1]) && свободно(ф.x, ф.y, toDigit(move[1]), move[2] - 48))
                                ||
                                (ф.y == move[2] && свободно(ф.x, ф.y, toDigit(move[1]), move[2] - 48))

                            )
                            )
                        {
                            ф.x = toDigit(move[1]);
                            ф.y = move[2] - 48;
                            if (взятиеФигуры == true)
                            {
                                Фигура фигураНаУдаление = new Фигура();
                                foreach (Фигура ф1 in БелыеФигуры)
                                {
                                    if (ф1.x == ф.x && ф1.y == ф.y)
                                    {
                                        фигураНаУдаление = ф1;
                                        break;
                                    }
                                }
                                БелыеФигуры.Remove(фигураНаУдаление);
                            }
                            break;
                        }
                    }
                }
                if (move[0] == 'B') // Bf3 --- Bef4 B1g5 ---
                {
                    foreach (Фигура ф in ЧерныеФигуры)
                    {
                        if (
                            ф.тип == "слон"
                            &&
                            (
                                (Math.Abs(ф.x - toDigit(move[1])) == Math.Abs(ф.y - (move[2] - 48))) && свободно(ф.x, ф.y, toDigit(move[1]), move[2] - 48)

                            )
                            )
                        {
                            ф.x = toDigit(move[1]);
                            ф.y = move[2] - 48;
                            if (взятиеФигуры == true)
                            {
                                Фигура фигураНаУдаление = new Фигура();
                                foreach (Фигура ф1 in БелыеФигуры)
                                {
                                    if (ф1.x == ф.x && ф1.y == ф.y)
                                    {
                                        фигураНаУдаление = ф1;
                                        break;
                                    }
                                }
                                БелыеФигуры.Remove(фигураНаУдаление);
                            }
                            break;
                        }
                    }
                }
                if (move[0] == 'Q') // Qf3
                {
                    foreach (Фигура ф in ЧерныеФигуры)
                    {
                        if (
                            ф.тип == "ферзь"
                            )
                        {
                            ф.x = toDigit(move[1]);
                            ф.y = move[2] - 48;
                            if (взятиеФигуры == true)
                            {
                                Фигура фигураНаУдаление = new Фигура();
                                foreach (Фигура ф1 in БелыеФигуры)
                                {
                                    if (ф1.x == ф.x && ф1.y == ф.y)
                                    {
                                        фигураНаУдаление = ф1;
                                        break;
                                    }
                                }
                                БелыеФигуры.Remove(фигураНаУдаление);
                            }
                            break;
                        }
                    }
                }
                if (move[0] == 'K') // Kf3
                {
                    foreach (Фигура ф in ЧерныеФигуры)
                    {
                        if (
                            ф.тип == "король"
                            )
                        {
                            ф.x = toDigit(move[1]);
                            ф.y = move[2] - 48;
                            if (взятиеФигуры == true)
                            {
                                Фигура фигураНаУдаление = new Фигура();
                                foreach (Фигура ф1 in БелыеФигуры)
                                {
                                    if (ф1.x == ф.x && ф1.y == ф.y)
                                    {
                                        фигураНаУдаление = ф1;
                                        break;
                                    }
                                }
                                БелыеФигуры.Remove(фигураНаУдаление);
                            }
                            break;
                        }
                    }
                }

                //to do 2 пешки на 1-й вертикале
                if (move[0] == 'a' || move[0] == 'b' || move[0] == 'c' || move[0] == 'd' || move[0] == 'e' || move[0] == 'f' || move[0] == 'g' || move[0] == 'h') //e2 -> e4
                {
                    foreach (Фигура ф in ЧерныеФигуры)
                    {
                        if (
                            ф.тип == "пешка" &&
                            ф.x == toDigit(move[0])
                            )
                        {
                            ф.x = toDigit(move[0]);
                            ф.y = move[1] - 48;
                            if (взятиеФигуры == false) // e4
                            {
                                ф.x = toDigit(move[0]);
                                ф.y = move[1] - 48;
                            }
                            if (взятиеФигуры == true) // de4
                            {
                                ф.x = toDigit(move[1]);
                                ф.y = move[2] - 48;
                                Фигура фигураНаУдаление = new Фигура();
                                foreach (Фигура ф1 in БелыеФигуры)
                                {
                                    if (ф1.x == ф.x && ф1.y == ф.y)
                                    {
                                        фигураНаУдаление = ф1;
                                        break;
                                    }
                                }
                                БелыеФигуры.Remove(фигураНаУдаление);
                            }
                            break;
                        }
                    }
                }
                if (move.Length >= 5 && move.Substring(0, 5) == "O-O-O")
                {
                    foreach (Фигура ф in ЧерныеФигуры)
                    {
                        if (ф.тип == "король")
                        {
                            ф.x = 3;
                            ф.y = 8;
                            break;
                        }
                    }
                    foreach (Фигура ф in ЧерныеФигуры)
                    {
                        if (ф.тип == "тура" && ф.x == 1)
                        {
                            ф.x = 4;
                            ф.y = 8;
                        }
                    }
                }
                else if (move.Length >= 3 && move.Substring(0, 3) == "O-O")
                {
                    foreach (Фигура ф in ЧерныеФигуры)
                    {
                        if (ф.тип == "король")
                        {
                            ф.x = 7;
                            ф.y = 8;
                            break;
                        }
                    }
                    foreach (Фигура ф in ЧерныеФигуры)
                    {
                        if (ф.тип == "тура" && ф.x == 8)
                        {
                            ф.x = 6;
                            ф.y = 8;
                        }
                    }
                }


                // вызываем перерисовку
                Invalidate();
                // передаем ход противоположной стороне
                ходБелых = true;
            }
        }