C++ Builder(игра шашки)

[Necromanсer]

Шашки с компом
Можете написать пояснение
#include <vcl.h>
#include <stdio.h>
#pragma hdrstop

#include "untMain.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

#define Sign(x) ((x > 0) ? 1 : ((x < 0) ? -1 : 0)) //Для чево ето подробно
#define CanEat_White 24 //???
#define CanEat_Black 25 //???

TfrmMain *frmMain;

bool bMove = 0, bComp[2] = {false, true}; //Чей ход //??? bMove = 0
TBoard Board; //Игровая доска
TMove CurMove; //Текущий ход
TMoves MoveList; //Список ходов
int Level = 6, LevelComp[2] = {6, 6}; //Уровень сложности
//Как поменять уровень сложности
//??? Истиность LevelComp[2] = {6, 6} ето перебырает камп сколько шашек одного играка и кампа
//??? А в какой функции есть переворот пешки на дамку
//??? Напышить подробно как компютер выбырает правыльный ход (напышить подробно как работает штучный интелект)
//??? В низу програмы написаны вопросы и где написаны " //??? ", прашу ответить.
//---------------------------------------------------------------------------
__fastcall TfrmMain::TfrmMain(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::FormKeyDown(TObject *Sender, WORD &Key,
TShiftState Shift)
{
switch (Key)
{
case 27: //Esc
Application->Terminate();
break;
case 40: //F2
DebMoves (&MoveList);
break;
case 39: //F3
DebInt (CountPos(Board, bMove));
break;

}
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::mnuGamExitClick(TObject *Sender)
{
Application->Terminate();
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::FormCreate(TObject *Sender)
{
// mmBlue->Lines->Clear();
bComp[0] = 1;//frmOptions -> rgrBlue -> ItemIndex;
bComp[1] = 0;//frmOptions -> rgrWhite -> ItemIndex;

NewGame();
//При загрузке начало новой игры
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::mnuGamNewClick(TObject *Sender)
{
bComp[0] = frmOptions -> rgrBlue -> ItemIndex;
bComp[1] = 0;//frmOptions -> rgrWhite -> ItemIndex;

NewGame();
//Выбран пункт новая игра

}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::NewGame () //Инициализация
{
int i; //Служебная переменная, для цикла
bMove = 1; //???
imgBoard -> Picture = img_board -> Picture;
//Зангрузка изображения
// Расстановка шашек компьютера
for (i = 0; i < 12; i++)
{
Board.Ch[i].X = (i & 3) * 2 + 1 - ((i / 4) & 1); //?? Прынцып расстановка шашек компьютера
Board.Ch[i].Y = i / 4; //?? Прынцып расстановка шашек компьютера
Board.Ch[i].bDead = 0; //?? Пачему Board.Ch[i].bDead = 0
Board.Ch[i].bWoman = 0; //?? Пачему Board.Ch[i].bWoman = 0
}
// Расстановка шашек игрока
for (i = 0; i < 12; i++)
{
Board.Ch[i + 12].X = 7 - ((i & 3) * 2 + 1 - ((i / 4) & 1));
Board.Ch[i + 12].Y = 7 - (i / 4);
Board.Ch[i + 12].bDead = 0;
Board.Ch[i + 12].bWoman = 0;
}
MoveList.Count = 0; //??0 Пачему 0
CurMove.Count = 0; //??= Пачему 0
BuildMovesList (Board, &MoveList, bMove); //???
DrawBoard (Board, 24); //отобразить доску
//mmBlue -> Lines -> Clear();
//mmWhite -> Lines -> Clear();
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain:rawBoard (TBoard Brd, int Num) //Отображение оставшихся шашек
{
imgBoard -> Picture = img_board -> Picture;
int i; //Служебная переменная, для цикла
for (i = 0; i < 24; i++)
{
if (Brd.Ch[i].bDead) continue; //???
int Ind; //?? Что означает переменная " Ind "
if (Num == i) Ind = 4 + Brd.Ch[i].bWoman; else Ind = 1 - (i / 12) + 2 * Brd.Ch[i].bWoman; //??? Тут подробно
imlPict -> Draw (imgBoard -> Canvas, 50 * Brd.Ch[i].X, 50 * Brd.Ch[i].Y, Ind, true); //??? Тут подробно
//Вывод очередной шашки
}

imgBoard -> Refresh(); //???
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain:ebInt (int N) //Кто ходит
{
char s[40]; //Выводимое сообщение
sprintf (s, "%d", N); //??? зачем n
tmrGame -> Enabled = false;
ShowMessage (s); //??? В переменной " S " содержыт какой текс
tmrGame -> Enabled = true;
}
//---------------------------------------------------------------------------
bool __fastcall TfrmMain::CanEat (TBoard Brd, int Num) //Функция, кторая проверяет что нужно бить
{
if (Num < 24)
{
if (Brd.Ch[Num].bDead) return false;
if (!Brd.Ch[Num].bWoman) //Для компьютера
{
char i = Num;
//Получение координат на доске
int X = Brd.Ch[Num].X; //??? Подробно
int Y = Brd.Ch[Num].Y;

//Проверка по всем направлениям
for (int k = -1; k < 3; k += 2) for (int j = -1; j < 3; j += 2)
{
char X1 = X + k + k;
char Y1 = Y + j + j;
if (X1 < 0) continue; //Если в пределах, то продолжение
if (X1 > 7) continue;
if (Y1 < 0) continue;
if (Y1 > 7) continue;
char tmp = GetCheckType (Brd, X + k , Y + j);//??? Что означает " GetCheckType " и " Brd "
if (tmp) if (((tmp - 1) / 2) + (i/12) == 1) //??? Подробно
{
//Функция для проверки
if (GetCheckType (Brd, X1, Y1) == 0) return true; //???
}
}
return false;
} else { //Для игрока
int X = Brd.Ch[Num].X;
int Y = Brd.Ch[Num].Y;
for (int k = -1; k < 3; k += 2) for (int j = -1; j < 3; j += 2)
{
char X1 = X + k, Y1 = Y + j;
char State = 0; //??? Что означает State и пачему " 0 "
while (1) //??? пачему " 1 "
{
if (X1 < 0) break; //Если выход за пределы, то обрывание
if (X1 > 7) break;
if (Y1 < 0) break;
if (Y1 > 7) break;
char tmp = GetCheckType (Brd, X1, Y1); //???
if (!tmp) //???
{
if (State) return true;
} else {
if (State) break; //???
if (((tmp - 1) / 2) + (Num/12) == 1) State = 1; else break; //??? Пдробно (((tmp - 1) / 2) + (Num/12) == 1)
}
X1 += k; //???
Y1 += j;
}
}
return false;
}
} else {
//Проверка каждой из клеток
for (int i = 12 * (Num - 24); i < 12 * (Num - 24) + 12; i++)
{
if (Brd.Ch[i].bDead) continue; //???
if (CanEat (Brd, i)) return true; //???
}
return false;
}
}
//---------------------------------------------------------------------------

char __fastcall TfrmMain::GetCheckType (TBoard Brd, int X, int Y) //Тип текущей шашки
{
// возвращаемые значения:
// 2 - синие компьютер
// 3 - белые

int i; //Служебная переменная, для цикла
for (i = 0; i < 24; i++) if (Brd.Ch[i].X == X) if (Brd.Ch[i].Y == Y) if (!Brd.Ch[i].bDead) //??? Подробно
return 1 + 2 * (i / 12) + Brd.Ch[i].bWoman; //??? Подробно
return 0;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::BuildMovesList (TBoard Brd, TMoves* MVL, bool bMove) //Генерация следующего кода
{
short Cnt = 0; //Щетчик сделанных ходов
if (!CanEat (Brd, 24 + bMove)) //Если не нужно бить (!CanEat (Brd, 24 + bMove)) Что тут означает " !CanEat " и " Brd " и " 24 + bMove "
{
for (int i = bMove * 12; i < 12 + bMove * 12; i++) //??? Подробно " bMove " и " 12 + bMove * 12 "
{
if (Brd.Ch[i].bDead) continue;
char X = Brd.Ch[i].X;
char Y = Brd.Ch[i].Y;
if (!Brd.Ch[i].bWoman) //Для компьютера
{
if (!bMove) if (Y == 7) continue; //??? " !bMove " что означает ета переменная
if (bMove) if (Y == 0) continue;
if (X > 0)
{
if (GetCheckType (Brd, X - 1, Y + (1 - (i/12)*2)) == 0) //?? Напышить алгоритм пачему если текущая ячейка пуста
{
//Определение координат
MVL -> Moves[Cnt].Count = 2; //??? Что означает " MVL " и " Moves[Cnt].Count " и пачему ано равно 2
MVL -> Moves[Cnt].Move[0] = X + 8 * Y; //??? Что означает и " Moves[Cnt].Move[0] " и пачему ано равно X + 8 * Y я так думаю ето пешку на дамку обращает
MVL -> Moves[Cnt++].Move[1] = (X - 1) + 8 * (Y + (1 - (i/12)*2)); //??? Пачему " Moves[Cnt++].Move[1] " тут 1 и что означает " Cnt++ "
}
}
if (X < 7)
{
if (GetCheckType (Brd, X + 1, Y + (1 - (i/12)*2)) == 0) //??? Напышить подробно
{
MVL -> Moves[Cnt].Count = 2;
MVL -> Moves[Cnt].Move[0] = X + 8 * Y;
MVL -> Moves[Cnt++].Move[1] = (X + 1) + 8 * (Y + (1 - (i/12)*2));
}
}
} else //Для игрока
{
for (int k = -1; k < 3; k += 2) for (int j = -1; j < 3; j += 2)
{
char X1 = X + k, Y1 = Y + j;
while (1)
{
if (X1 < 0) break; //Если выход за пределы, то обрывание
if (X1 > 7) break;
if (Y1 < 0) break;
if (Y1 > 7) break;
if (GetCheckType (Brd, X1, Y1)) break;
MVL -> Moves[Cnt].Count = 2;
MVL -> Moves[Cnt].Move[0] = X + 8 * Y;
MVL -> Moves[Cnt++].Move[1] = X1 + 8 * Y1;
X1 = X1 + k;
Y1 = Y1 + j;
}
}
}
}
} else //Если нужно бить
{
for (int i = bMove * 12; i < 12 + bMove * 12; i++)
{
if (Brd.Ch[i].bDead) continue;
if (!CanEat (Brd, i)) continue;
char X = Brd.Ch[i].X;
char Y = Brd.Ch[i].Y;
if (!Brd.Ch[i].bWoman) //Для компьютера
{
for (int k = -1; k < 3; k += 2) for (int j = -1; j < 3; j += 2)
{
char X1 = X + k + k;
char Y1 = Y + j + j;
if (X1 < 0) continue; //Если в пределах доски, то продолжаем
if (X1 > 7) continue;
if (Y1 < 0) continue;
if (Y1 > 7) continue;
char tmp = GetCheckType (Brd, X + k , Y + j);
if (tmp) if (((tmp - 1) / 2) + (i/12) == 1) //???
{
if (GetCheckType (Brd, X1, Y1) == 0)
{
TMoves tmpS;
TMove tmp;
tmp.Count = 2;
tmp.Move[0] = X + 8 * Y;
tmp.Move[1] = (X + k + k) + 8 * (Y + j + j);
BuildMovesEat (Brd, tmp, &tmpS); //???
for (int r = 0; r < tmpS.Count; r++) MVL -> Moves[Cnt++] = tmpS.Moves[r]; //???
}
}
}
} else //Для игрока
{
for (int k = -1; k < 3; k += 2) for (int j = -1; j < 3; j += 2)
{
char State = 0;
char X1 = X + k, Y1 = Y + j;
while (1)
{
if (X1 < 0) break; //Если выход за пределы, то обрывание
if (X1 > 7) break;
if (Y1 < 0) break;
if (Y1 > 7) break;
char tmp = GetCheckType (Brd, X1, Y1);
if (!tmp) if (State)
{
TMove tmpMV;
TMoves tmpMVS;
tmpMV.Count = 2;
//Определение допустимых координат
tmpMV.Move[0] = X + 8 * Y;
tmpMV.Move[1] = X1 + 8 * Y1;
BuildMovesEat (Brd, tmpMV, &tmpMVS);
for (int r = 0; r < tmpMVS.Count; r++) MVL -> Moves[Cnt++] = tmpMVS.Moves[r];
}
if (tmp)
{
if (State) break;
if ((tmp - 1) / 2 + (i/12) == 1) State = 1; else break;
}
X1 += k;
Y1 += j;
}
}
}
}
}
MVL -> Count = Cnt;
}

[Necromanсer]

//---------------------------------------------------------------------------

void __fastcall TfrmMain:ebMoves (TMoves* MVL) //Варианты ходов
{
for (int i = 0; i < MVL -> Count; i++)
DebMove (MVL -> Moves[i]); //???
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain:ebMove (TMove MV) //Вывод разметки
{
char s[100]; //Строка сообщение //??? Какого
char *chX = "ABCDEFGH", *chY = "12345678"; //Подписи по X и Y
s[0] = 0;
for (int i = 0; i < MV.Count; i++)
{
char d[100]; //Строка сообщение
sprintf (d, "%s %c%c", s, chX[MV.Move[i] & 7], chY[MV.Move[i] >> 3]);
StrCopy (s, d);
}
ShowMessage (s);
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::tmrGameTimer(TObject *Sender) //Установка свийств и значений
{
Level = LevelComp[bMove];//???
if (bComp[bMove]) //???
{
tmrGame -> Enabled = false;
Sleep (100); //Интервал
doCompMove (Board, &CurMove); //???
ApplyMove (&Board, CurMove); //???
LogMove (CurMove, bMove); //???
bMove = 1 - bMove; //???
BuildMovesList (Board, &MoveList, bMove); //???
CurMove.Count = 0; //???
DrawBoard (Board, 25); //???
EndGame (CheckWin (Board, bMove)); //???
tmrGame -> Enabled = true;
}
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::imgBoardMouseMove(TObject *Sender, //Вычисление текущих координат мыши
TShiftState Shift, int X, int Y)
{
char* chX = "ABCDEFGH", *chY="12345678"; //Подписи по осям
char chXY[10]; //???
X = X / 50; ////??? Почему на 50
Y = Y / 50;
sprintf (chXY, "%c%c", chX[X], chY[Y]);
lblMove -> Caption = chXY;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::imgBoardMouseDown(TObject *Sender, //Опредение на какой из ячеек был щелчок
TMouseButton Button, TShiftState Shift, int X, int Y)
{
if (bComp[bMove]) return;
X = X / 50;
Y = Y / 50;
char tmp;
tmp = GetCheckType (Board, X, Y);
if (tmp)
{
if (CurMove.Count > 1) return;
if ((tmp - 1) / 2 + bMove == 1) return; //???
CurMove.Count = 1;
CurMove.Move[0] = X + 8 * Y; //???
DrawBoard (Board, GetCheckNum (Board, X, Y)); //???
} else {
CurMove.Move[CurMove.Count++] = X + 8 * Y;
bool bCan = false, bCanElse = false;
for (int k = 0; k < MoveList.Count; k++)
{
bool bCanMove = true;
for (int i = 0; i < CurMove.Count; i++)
{
bCanMove = bCanMove && (CurMove.Move[i] == MoveList.Moves[k].Move[i]); //???
}
if (bCanMove)
{
bCan = true;
bCanElse = (CurMove.Count < MoveList.Moves[k].Count);
break;
}
}
if (!bCan) //Если ход запрещен
{
CurMove.Count = 0; //???
DrawBoard (Board, 25);
return;
}
if (!bCanElse) //Ход разрешен
{
ApplyMove (&Board, CurMove); //???
LogMove (CurMove, bMove); //???
bMove = 1 - bMove; //???
BuildMovesList (Board, &MoveList, bMove); //???
CurMove.Count = 0; //???
DrawBoard (Board, 25);
EndGame (CheckWin (Board, bMove)); //???
}
}
}
//---------------------------------------------------------------------------

char __fastcall TfrmMain::GetCheckNum (TBoard Brd, int X, int Y) //Проверка координат
{
for (int i = 0; i < 24; i++) if (Brd.Ch[i].X == X) if (Brd.Ch[i].Y == Y) if (!Brd.Ch[i].bDead) return i;
return -1; //??? Пачему -1
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::ApplyMove (TBoard* Brd, TMove MV) //Сделать ход
{
char Num = GetCheckNum (*Brd, MV.Move[0] & 7, MV.Move[0] >> 3); //???
if ((MV.Count == 2) && (abs ((MV.Move[0] & 7) - (MV.Move[1] & 7)) == 1)) //???
{
} else for (int i = 0; i < MV.Count - 1; i++)
{
char X = MV.Move[i + 1] & 7; //Определение координат
char Y = MV.Move[i + 1] >> 3; //???
char k = Sign (X - (MV.Move[i] & 7)); //???
char j = Sign (Y - (MV.Move[i] >> 3)); //???
char X1 = (MV.Move[i] & 7) + k; //???
char Y1 = (MV.Move[i] >> 3) + j; //???
while (X1 != X) //???
{
char N = GetCheckNum (*Brd, X1, Y1); //??? А зачем *
if (N >= 0) if (N < 24) Brd -> Ch[N].bDead = 1; //??? Пачему 1
X1 += k;
Y1 += j;
}
}
Brd -> Ch[Num].X = MV.Move [MV.Count - 1] & 7; //???
Brd -> Ch[Num].Y = MV.Move [MV.Count - 1] >> 3; //???
if (Num/12) if (!Brd -> Ch[Num].Y) Brd -> Ch[Num].bWoman = 1; //???
if (!(Num/12)) if (Brd -> Ch[Num].Y == 7) Brd -> Ch[Num].bWoman = 1; //???
}
//---------------------------------------------------------------------------

char __fastcall TfrmMain::CheckWin (TBoard Brd, bool bMove) //Определние победителя
{
// возарвщаемые значения:
// 0 - Игра еще не закончена
// 1 - синие победели
// 2 - белые победили

char cB = 0, cW = 0; //Кто победитель
for (int i = 0; i < 24; i++)
{
if (!Brd.Ch[i].bDead)
{
if (i < 12) cB++; else cW++;
}
}
if (!cB) return 2;
if (!cW) return 1;
TMoves MVL;
BuildMovesList (Brd, &MVL, bMove); //???
if (MVL.Count == 0) return 2 - bMove; //???
return 0;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain:ndGame (char EndStatus) //??? откуда передается етот параметр EndStatus
{
if (!EndStatus) return;
tmrGame -> Enabled = false;
switch (EndStatus)
{
case 1:
ShowMessage ("Синие выиграли!");
break;
case 2:
ShowMessage ("Белые выиграли!");
break;
}
tmrGame -> Enabled = true;
NewGame ();
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::BuildMovesEat (TBoard Brd, TMove MV, TMoves* MVL) //"Съесть" чужую шашку
{
int Cnt = 0; //Щетчик
TBoard Brd2; //Поле
Brd2 = Brd;
char Num = GetCheckNum (Brd, MV.Move[0] & 7, MV.Move[0] >> 3); //???
bool bTmp = Brd.Ch[Num].bWoman; //???
ApplyMove (&Brd, MV); //???
if (Brd.Ch[Num].bWoman != bTmp) //Для компьютера //??? bTmp и Brd.Ch[Num].bWoman что ани означают
{
MVL -> Count = 1; //???
MVL -> Moves[0] = MV; //???
return;
}
if (!CanEat (Brd, Num)) //Если не нужно бить
{
MVL -> Count = 1;
MVL -> Moves[0] = MV;
return;
}
char X = Brd.Ch[Num].X;
char Y = Brd.Ch[Num].Y;

//Для игрока
if (!Brd.Ch[Num].bWoman)
{
for (int k = -1; k < 3; k += 2) for (int j = -1; j < 3; j += 2)
{
char X1 = X + k + k;
char Y1 = Y + j + j;
if (X1 < 0) continue; //Если в пределах доски, то продолжаем
if (X1 > 7) continue;
if (Y1 < 0) continue;
if (Y1 > 7) continue;
char tmp = GetCheckType (Brd, X + k , Y + j);
if (tmp) if (((tmp - 1) / 2) + (Num/12) == 1) //??? Подробно
{
if (GetCheckType (Brd, X1, Y1) == 0)
{
MV.Move[MV.Count++] = (X + k + k) + 8 * (Y + j + j);
TMoves tmpS;
BuildMovesEat (Brd2, MV, &tmpS); //???
for (int r = 0; r < tmpS.Count; r++)
MVL -> Moves[Cnt++] = tmpS.Moves[r];
MV.Count--;
}
}
}
} else
//Для компьютера
{
for (int k = -1; k < 3; k += 2) for (int j = -1; j < 3; j += 2)
{
char X1 = X + k;
char Y1 = Y + j;
char State = 0;
while (1)
{
if (X1 < 0) break; //Если выход за пределы, то обрывание
if (X1 > 7) break;
if (Y1 < 0) break;
if (Y1 > 7) break;
char tmp = GetCheckType (Brd, X1, Y1);
if (!tmp) if (State)
{
MV.Move[MV.Count++] = X1 + 8 * Y1;
TMoves tmpS;
BuildMovesEat (Brd2, MV, &tmpS);
for (int r = 0; r < tmpS.Count; r++)
MVL -> Moves[Cnt++] = tmpS.Moves[r];
MV.Count--;
}
if (tmp)
{
if (State) break;
if ((tmp - 1) / 2 + (Num/12) == 1) State = 1; else break;
}
X1 += k;
Y1 += j;
}
}
}
MVL -> Count = Cnt;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::SaveGame (char* FileName) //Сохранение игры
{
FILE* f = fopen (FileName, "w"); //Файл для сохранения
if (f == NULL)
{
ShowMessage ("Невозможно открыть файл");
return;
}
fwrite (&Board, sizeof (Board), 1, f); //Запись в файл расстановки шашек
fwrite (&bMove, 1, 1, f);
fclose (f);
ShowMessage ("Игра сохранена");
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::LoadGame (char* FileName) //Загрузка из файла
{
FILE* f = fopen (FileName, "r"); //Файл для загрузки
if (f == NULL)
{
ShowMessage ("Невозможно открыть файл");
return;
}
fread (&Board, sizeof (Board), 1, f);
fread (&bMove, 1, 1, f);
fclose (f);
BuildMovesList (Board, &MoveList, bMove); //Загрузка по сохраненным координатам
DrawBoard (Board, 25);

}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::LogMove (TMove MV, bool bMove) //Запись ходов
{
char s[100]; //Строка сообщение
char *chX = "ABCDEFGH", *chY = "12345678"; //Подписи
s[0] = 0;
for (int i = 0; i < MV.Count; i++)
{
char d[100];
sprintf (d, "%s %c%c", s, chX[MV.Move[i] & 7], chY[MV.Move[i] >> 3]);
StrCopy (s, d);
}

}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::mnuGamSaveClick(TObject *Sender)
{
if (dlgSave -> Execute())
{
SaveGame (dlgSave -> FileName.c_str());
}
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::mnuGamOpenClick(TObject *Sender)
{
if (dlgOpen -> Execute())
{
LoadGame (dlgOpen -> FileName.c_str());
}
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::doCompMove (TBoard Brd, TMove* MV)
{
doBestMove (Brd, bMove, Level, MV); //Ходит компьютер
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::mnuOptionsClick(TObject *Sender) //Установка опций
{
tmrGame -> Enabled = false;
frmOptions -> rgrBlue -> ItemIndex = bComp[0];
frmOptions -> rgrWhite -> ItemIndex = bComp[1];
frmOptions -> rgrBlueSkill -> ItemIndex = LevelComp[0] - 2;
frmOptions -> rgrWhiteSkill -> ItemIndex = LevelComp[1] - 2;
// frmOptions -> chbShowMoves -> Checked = DrawLines;
int ret;

if (ret == 2)
{
bComp[0] = frmOptions -> rgrBlue -> ItemIndex;
bComp[1] = frmOptions -> rgrWhite -> ItemIndex;

}
tmrGame -> Enabled = true;
}
//---------------------------------------------------------------------------

int __fastcall TfrmMain::CountPos (TBoard Brd, bool bMove)//Функция для определения правильности хода
{
int i, Result; //Служебная переменная, для цикла
Result = 0;
for (i = 0; i < 24; i++) if (!Brd.Ch[i].bDead)
{
if (!(i/12)) Result += 8 + Brd.Ch[i].Y + Brd.Ch[i].bWoman * 8; else Result -= 15 - Brd.Ch[i].Y + Brd.Ch[i].bWoman * 8;
}
if (bMove) return -Result;
return Result;
}

//---------------------------------------------------------------------------

void __fastcall TfrmMain::doBestMove (TBoard Brd, bool bMove, char Deep, TMove* MV) //Алгоритм ходов компьютера.
//Компьютер делает "праильные ходы"
{ // Ету функцию подробно с вступом и высновком и подробно обяснить алгорытм работы
TMoves MVL;
BuildMovesList (Brd, &MVL, bMove); //???
if (MVL.Count == 1) //??? Пачему 1
{
*MV = MVL.Moves[0]; //??? Пачему *
return;
}
if (Deep == Level) //??? откуда передався параметр
{

}
if (Deep <= 0) //??? Пачему <0
{
int MaxRes = -99999; //??? Пачему MaxRes = -99999
int MaxPos = 0; //??? Пачему MaxPos = 0
for (int i = 0; i < MVL.Count; i++)
{
TBoard Brd2 = Brd; //???
ApplyMove (&Brd2, MVL.Moves[i]); //???
int CurRes = CountPos (Brd2, bMove); //???
Randomize ();
if (CurRes == MaxRes) if (rand() & 1) MaxPos = i; //???
if (CurRes > MaxRes) //???
{
MaxPos = i; //???
MaxRes = CurRes; //???
}
}
*MV = MVL.Moves[MaxPos]; //??? //??? Пачему *
} else {
int MaxRes = -99999;
int MaxPos = 0;
for (int i = 0; i < MVL.Count; i++)
{
TBoard Brd2 = Brd;
ApplyMove (&Brd2, MVL.Moves[i]);
TMove tmpMV;
doBestMove (Brd2, 1 - bMove, Deep - 1, &tmpMV);
ApplyMove (&Brd2, tmpMV);
doBestMove (Brd2, bMove, Deep - 2, &tmpMV);
ApplyMove (&Brd2, tmpMV);
int CurRes = CountPos (Brd2, bMove);
Randomize ();
if (CurRes == MaxRes) if (rand() & 1) MaxPos = i;
if (CurRes > MaxRes)
{
MaxPos = i;
MaxRes = CurRes;
}
if (Deep == Level)
{

Application -> ProcessMessages();
}
}
*MV = MVL.Moves[MaxPos];
}
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::mnuAboutClick(TObject *Sender)
{
ShowMessage ("Игру написав");
}
//---------------------------------------------------------------------------

[programmer]

#include <vcl.h>
а это что за библиотека? а она стандартная?

[Keshun]

А какой оптимальный алгоритм для реализации дамок и их взятий? Здесь он реализован вообще?

[Keshun]

Друг делает отрисовку шашечных партий, очень нужен алгоритм взятия дамок... Подскажите кто-нибудь!

[Diryktivety]

Я тоже пытался создать игру шашки, но не вышло! Там очень много мелочей в правилах шашок. Поэтому советую посмотреть правила! Вот вам ссылка что бы вы не парились http://www.gambiter.ru/checkers/item...i-pravila.html