//константы размеров доски и окружения
enum
{
e_lef_info_wid=10,//пространство слева от доски
e_rig_info_wid=50,//пространство справа от доски
e_top_info_hig=10,//пространство сверху от доски
e_bot_info_hig=10,//пространство снизу от доски

e_wid_boardLines=1,//толщина линий сетки доски (лучше не менять)
};

//доска
class CReversi::CBoard
{
enum ee_sizes
{
e_xmax=8,
e_ymax=8,
};

CCell m_NullCell;
CCell m_Cells[e_xmax*e_ymax];

public:
typedef void(*tdf_cellGotNewType)
(CWnd* pw, CBoard& boardToChange, const DWORD x_zb,const DWORD y_zb);

CBoard(const CBoard& src)
{
(*this)=src;
}

void operator=(const CBoard& src)
{
m_NullCell=src.m_NullCell;

for(int i=0; i<e_xmax*e_ymax; i++)
{
m_Cells[i]=src.m_Cells[i];
}
}

//получить ссылку на клетку. Если индекс за пределами доски,
//вернётся ссылка на null-клетку
CCell& Cell(DWORD x_zb,DWORD y_zb)
{
if(x_zb>=e_xmax || y_zb>=e_ymax)
{
return m_NullCell;
}
else
{
return m_Cells[e_xmax*x_zb+y_zb];
}
}

const CCell& Cell(DWORD x_zb,DWORD y_zb)const
{
return Cell(x_zb,y_zb);
}

CBoard()
{
m_NullCell.SetNull_();
}

//начальное состояние доски
//4 фишки в центре доски
void SetToBeginState()
{
Cell(3,3).SetWhite();
Cell(4,4).SetWhite();
Cell(3,4).SetBlack();
Cell(4,3).SetBlack();
}

//сделать ход (поставить фишку)
//bWhite == true  — белая фишка
// == false — чёрная фишка
//bTestMode — если true, то фишки доски реально не меняются, происходит лишь
//моделирование хода
//Возвращает количество зажатых фишек. Если 0 — то ход невозможен
DWORD SetNewBone(
const DWORD x_zb,
const DWORD y_zb,
const bool bSetWhiteBone,
CWnd* pWinForCallBack=0,
CBoard::tdf_cellGotNewType cb=0
)
{
DWORD dwdCommonCount=0;//количество зажатых фишек

CCell& aimCell=Cell(x_zb,y_zb);

//убеждаемся, что клетка ещё пуста
if(!aimCell.IsEmpty())return 0;

//цвет фишки, которую хотят поставить
const CCell::ee_types AlliedType=
(bSetWhiteBone?CCell::e_white:CCell::e_black);

//цвет фишек врага
const CCell::ee_types EnemyType_=
CCell::st_GetOpponentTypeFor(AlliedType);

//ставим фишку
aimCell.SetType(AlliedType);
if(cb)cb(pWinForCallBack,*this,x_zb,y_zb);

//сканируем 8 направлений на предмет зажимания
//фишек врага между своими
DWORD dx,dy;
for(dx=-1; dx!=2; dx++)
{
for(dy=-1; dy!=2; dy++)
{
//в этом направлении ещё не встречено фишки врага
bool bWasEnemy_=false;

//в этом направлении ещё не встречено своей фишки
bool bWasAllied=false;

//количество зажатых фишек врага в этом направлении
DWORD dwdDirEnemyCount=0;

//рассматриваем это направление, прибавляя
DWORD x,y;
x=x_zb+dx;
y=y_zb+dy;
for(;;x+=dx, y+=dy)
{
//проверяем клетку, на которую только что сместились
CCell& currcell=Cell(x,y);

if(currcell.IsThisType(EnemyType_))
{
//отмечаем, что была вражеская фишка
bWasEnemy_=true;
dwdDirEnemyCount++;

//шагаем дальше
}
else
if(currcell.IsThisType(AlliedType))
{
//отмечаем, что встречена "своя" фишка
bWasAllied=true;

//возможно, зажали вражеские фишки
if(dwdDirEnemyCount>0
&& bWasEnemy_ && bWasAllied)
{
//зажали dwdDirEnemyCount фишек врага
dwdCommonCount+=dwdDirEnemyCount;

//переворачиваем зажатые фишки

//состав направления таков:
//1)первая  фишка==Cell(x_zb,y_zb),
//2)dwdDirEnemyCount вражеских
//3)последняя == Cell(x,y)

DWORD xRev=x_zb+dx;
DWORD yRev=y_zb+dy;
for(;xRev!=x && yRev!=y; xRev+=dx, yRev+=dy)
{
Cell(xRev,yRev).SetType(AlliedType);
if(cb)cb(pWinForCallBack,*this,xRev,yRev);
}
}

//направление пройдено
break;
}
else
{
//направление пройдено
break;
}
}//for
}//for
}//for

if(!dwdCommonCount)
{
//если ничего не зажато, исправляем поставленную было фишку
//убираем фишку
aimCell.SetEmpty();
if(cb)cb(pWinForCallBack,*this,x_zb,y_zb);
}

return dwdCommonCount;
}

void GetStatistics(
DWORD* pdwdBlackCount=0,
DWORD* pdwdWhiteCount=0,
bool* pbBoardIsFull_=0)const
{
if(pdwdBlackCount)*pdwdBlackCount=0;
if(pdwdWhiteCount)*pdwdWhiteCount=0;
if(pbBoardIsFull_)*pbBoardIsFull_=false;
DWORD dwdCommonCount=0;

DWORD x,y;
for(x=0; x<e_xmax; x++)
{
for(y=0; y<e_ymax; y++)
{
const CCell& C=Cell(x,y);

if(C.IsBlack())
{
dwdCommonCount++;
if(pdwdBlackCount)
{
(*pdwdWhiteCount)++;
}
}
else
if(C.IsWhite())
{
dwdCommonCount++;
if(pdwdWhiteCount)
{
(*pdwdWhiteCount)++;
}
}
}
}

if(pbBoardIsFull_)
{
if(dwdCommonCount)
{
*pbBoardIsFull_=true;
}
}
}

bool IsItPossibleToSetNewBone(const bool bSetWhiteBone)const
{
CBoard testBoard;
testBoard=*this;

DWORD x,y;
for(x=0; x<e_xmax; x++)
{
for(y=0; y<e_ymax; y++)
{
if(testBoard.SetNewBone(x,y,bSetWhiteBone))
{
return true;
}
}
}

return false;
}

void PaintBoard(CDC& dc,const CRect& BoardRect)
{
...
}

//вычисление прямоугольника клетки в прямоугольнике доски.
//Площадь прямоугольника доски может быть израсходована не вся-
// это учитывать при закраске прямоугольника доски
static bool st_GetCellRect(DWORD x_zb,DWORD y_zb,const CRect& BoardRect,CRect& CellRect)
{
int w=(BoardRect.Width()-e_wid_boardLines)/e_xmax;
int h=(BoardRect.Height()-e_wid_boardLines)/e_ymax;

if(!w || !h)
{
CellRect=CRect(0,0,0,0);
return false;
}

CellRect.left  =BoardRect.left +w*x_zb;
CellRect.right =CellRect.left  +w-1;
CellRect.top   =BoardRect.top  +h*y_zb;
CellRect.bottom=CellRect.top   +h-1;

return true;
}

//определение прямоугольника доски
//если вернёт false, значит прямоугольник доски равен CRect(0,0,0,0))
//прямоугольник принудительно делается квадратным -
//путём уменьшения более длинной стороны прямоугольника.
//в *pSpareRightSpace вернутся размеры "обрезков" снизу и справа
static bool st_GetBoardRect(const CRect& LayerRect,CRect& BoardRect,CSize* pBotRigSpareSize=0)
{
if(pBotRigSpareSize)*pBotRigSpareSize=CSize(0,0);
BoardRect=CRect(0,0,0,0);

if(LayerRect.Width ()<=e_lef_info_wid+e_rig_info_wid)return false;
if(LayerRect.Height()<=e_top_info_hig+e_bot_info_hig)return false;

//предварительный размер
CRect PreviewBoardRect=CRect
(
LayerRect.left  +e_lef_info_wid,
LayerRect.top   +e_top_info_hig,
LayerRect.right -e_rig_info_wid-1,
LayerRect.bottom-e_bot_info_hig-1
);

//делаем размер квадратным, уменьшая более длинную сторону
//и заодно находим величину обрезков до квадрата
int diff=0;
if(PreviewBoardRect.Width()>=PreviewBoardRect.Height())
{
diff=PreviewBoardRect.Width()-PreviewBoardRect.Height();
PreviewBoardRect.right-=diff;
if(pBotRigSpareSize)pBotRigSpareSize->cx=diff;
}
else
{
diff=PreviewBoardRect.Height()-PreviewBoardRect.Width();
PreviewBoardRect.bottom-=diff;
if(pBotRigSpareSize)pBotRigSpareSize->cy=diff;
}

//находим скорректированный размер
CRect BotRigCellRect;
if(!st_GetCellRect(e_xmax-1,e_ymax-1,PreviewBoardRect,BotRigCellRect))return false;
BoardRect=PreviewBoardRect;
BoardRect.right=BotRigCellRect.right+e_wid_boardLines;
BoardRect.bottom=BotRigCellRect.bottom+e_wid_boardLines;

return true;
}
};

static bool st_GetBoardRect(const CRect& LayerRect,CRect& BoardRect,CSize* pBotRigSpareSize=0)
static bool st_GetCellRect(DWORD x_zb,DWORD y_zb,const CRect& BoardRect,CRect& CellRect)

void PaintBoard(CDC& dc,const CRect& BoardRect)