//константы размеров доски и окружения
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)