void InitPlayScrn(int X, int Y)
{
	_PlayWin = new NewPlayWindow(); _PlayWin->Move(X, Y);

	//Iso Map Data
	_PlayWin->SetBasics(_PlayWin->GetOriginX(), _PlayWin->GetOriginY(), _PlayWin->GetWidth(), _PlayWin->GetHeight(), RHO_Map);
	_TestIsoL		= _PlayWin->GetCentTileX();
	_TestIsoR		= (_MainIsoW - 1) - _PlayWin->GetCentTileX();
	_TestIsoT		= _PlayWin->GetCentTileY();
	_TestIsoB		= (_MainIsoH - 1) - _PlayWin->GetCentTileY();

	//Hex Map Data
	_PlayWin->SetBasics(_PlayWin->GetOriginX(), _PlayWin->GetOriginY(), _PlayWin->GetWidth(), _PlayWin->GetHeight(), HEX_Map01);
	_TestHexL		= _PlayWin->GetCentTileX();
	_TestHexR		= (_MainHexW - 1) - _PlayWin->GetCentTileX();
	_TestHexT		= _PlayWin->GetCentTileY();
	_TestHexB		= (_MainHexH - 1) - _PlayWin->GetCentTileY();

	//SqrIso Map Data
	_PlayWin->SetBasics(_PlayWin->GetOriginX(), _PlayWin->GetOriginY(), _PlayWin->GetWidth(), _PlayWin->GetHeight(), DIA_Map);
	_TestSqrIsoL	= _PlayWin->GetCentTileX();
	_TestSqrIsoR	= (_MainSqrIsoW - 1) - _PlayWin->GetCentTileX();
	_TestSqrIsoT	= _PlayWin->GetCentTileY();
	_TestSqrIsoB	= (_MainSqrIsoH - 1) - _PlayWin->GetCentTileY();

	//Sqr Map Data
	_PlayWin->SetBasics(_PlayWin->GetOriginX(), _PlayWin->GetOriginY(), _PlayWin->GetWidth(), _PlayWin->GetHeight(), SQR_Map);
	_TestSqrL		= _PlayWin->GetCentTileX();
	_TestSqrR		= (_MainSqrW - 1) - _PlayWin->GetCentTileX();
	_TestSqrT		= _PlayWin->GetCentTileY();
	_TestSqrB		= (_MainSqrH - 1) - _PlayWin->GetCentTileY();

	_PWL1	= _PlayWin->gRectL() - 4;
	_PWL2	= _PlayWin->gRectL() + 1;
	_PWR	= _PlayWin->gRectR();
	_PWT	= _PlayWin->gRectT() - 4;
	_PWB	= _PlayWin->gRectB() + 1;
}
void TestMapCursor()
{
	int iWork1 = 0, iWork2 = 0, iWork3 = 0, iWork4 = 0;

	//Determine if need to show the cursor
	if(_pEngine->GetMouseX() > (_PlayWin->gRectL() - 20) && _pEngine->GetMouseX() < (_PlayWin->gRectR() + 20) &&
	   _pEngine->GetMouseY() > (_PlayWin->gRectT() - 20) && _pEngine->GetMouseY() < (_PlayWin->gRectB() + 20))
	{
		switch(_PlayWin->GetType())
		{
		case HEX_Map01:
			{
				//Get Starting numbers...					
				iWork1 = int((_pEngine->GetMouseX() - (_PlayWin->GetTileOffX() - ((_HexY & 1) * 24))) / _PlayWin->GetTileW());	//Course Value X
				iWork2 = int((_pEngine->GetMouseY() - (_PlayWin->GetTileOffY() - ((_HexY & 1) * 16))) / _PlayWin->GetTileH());	//Course Value Y
				iWork3 = int((_pEngine->GetMouseX() - (_PlayWin->GetTileOffX() - ((_HexY & 1) * 24))) % _PlayWin->GetTileW());	//Fine Value X
				iWork4 = int((_pEngine->GetMouseY() - (_PlayWin->GetTileOffY() - ((_HexY & 1) * 16))) % _PlayWin->GetTileH());	//Fine Value Y

				_ptCursor.x	= iWork1;
				_ptCursor.y	= (iWork2 * 2);

				//Top Quarter...
				if		(iWork4 <= int(_PlayWin->GetTileH() * 0.25))
				{
					//Left Quarter...
					if		(iWork3 <= int(_PlayWin->GetTileW() * 0.25))	{ _ptCursor.x -= 1; _ptCursor.y -= 1; }
					//Right Quarter...
					else if	(iWork3 >= int(_PlayWin->GetTileH() * 0.75))	{ _ptCursor.y -= 1; }
					else
					{
						//We don't have anything happen where all else fails...
						//This represents the center of the Tile that's meant
						//to be targeted by the User - M. White 15 March, 2019
					}
				}
				//Bottom Quarter...
				else if	(iWork4 >= int(_PlayWin->GetTileH() * 0.75))
				{
					//Left Quarter...
					if		(iWork3 <= int(_PlayWin->GetTileW() * 0.25))	{ _ptCursor.x -= 1; _ptCursor.y += 1; }
					//Right Quarter...
					else if	(iWork3 >= int(_PlayWin->GetTileH() * 0.75)) { _ptCursor.y += 1; }
					else
					{
						//We don't have anything happen where all else fails...
						//This represents the center of the Tile that's meant
						//to be targeted by the User - M. White 15 March, 2019
					}
				}
				else
				{
					//We don't have anything happen where all else fails...
					//This represents the center of the Tile that's meant
					//to be targeted by the User - M. White 15 March, 2019
				}
			}
			break;
		case RHO_Map:
			{
				//Get Starting numbers...
				iWork1		= int((_pEngine->GetMouseX() - _PlayWin->GetTileOffX()) / _PlayWin->GetTileW());	//Course Value X
				iWork2		= int((_pEngine->GetMouseY() - _PlayWin->GetTileOffY()) / _PlayWin->GetTileH());	//Course Value Y
				iWork3		= int((_pEngine->GetMouseX() - _PlayWin->GetTileOffX()) % _PlayWin->GetTileW());	//Fine Value X
				iWork4		= int((_pEngine->GetMouseY() - _PlayWin->GetTileOffY()) % _PlayWin->GetTileH());	//Fine Value Y

				_ptCursor.x	= iWork1;
				_ptCursor.y	= (iWork2 * 2);

				//Top Quarter...
				if		(iWork4 <= int(_PlayWin->GetTileH() * 0.2))
				{
					//Left Quarter...
					if		(iWork3 <= int(_PlayWin->GetTileW() * 0.2))	{ _ptCursor.x -= 1; _ptCursor.y -= 1; }
					//Right Quarter...
					else if	(iWork3 >= int(_PlayWin->GetTileH() * 0.8))	{ _ptCursor.y -= 1; }
					else
					{
						//We don't have anything happen where all else fails...
						//This represents the center of the Tile that's meant
						//to be targeted by the User - M. White 15 March, 2019
					}
				}
				//Bottom Quarter...
				else if	(iWork4 >= int(_PlayWin->GetTileH() * 0.8))
				{
					//Left Quarter...
					if		(iWork3 <= int(_PlayWin->GetTileW() * 0.2))	{ _ptCursor.x -= 1; _ptCursor.y += 1; }
					//Right Quarter...
					else if	(iWork3 >= int(_PlayWin->GetTileH() * 0.8)) { _ptCursor.y += 1; }
					else
					{
						//We don't have anything happen where all else fails...
						//This represents the center of the Tile that's meant
						//to be targeted by the User - M. White 15 March, 2019
					}
				}
				else
				{
					//We don't have anything happen where all else fails...
					//This represents the center of the Tile that's meant
					//to be targeted by the User - M. White 15 March, 2019
				}
			}
			break;
		case DIA_Map:
			{
				//Get Starting numbers...
				iWork1		= int((_pEngine->GetMouseX() - _PlayWin->GetTileOffX()) / _PlayWin->GetTileW());	//Course Value X
				iWork2		= int((_pEngine->GetMouseY() - _PlayWin->GetTileOffY()) / _PlayWin->GetTileH());	//Course Value Y
				iWork3		= int((_pEngine->GetMouseX() - _PlayWin->GetTileOffX()) % _PlayWin->GetTileW());	//Fine Value X
				iWork4		= int((_pEngine->GetMouseY() - _PlayWin->GetTileOffY()) % _PlayWin->GetTileH());	//Fine Value Y

				_WhatCommandCursor = _FineMouseTestArray[iWork3][iWork4];

				_ptCursor.x	= iWork1;
				_ptCursor.y	= (iWork2 * 2);

				//Top Quarter...
				if		(iWork4 <= int(_PlayWin->GetTileH() * 0.25))
				{
					//Left Quarter...
					if		(iWork3 <= int(_PlayWin->GetTileW() * 0.25))	{ _ptCursor.x -= 1; _ptCursor.y -= 1; }
					//Right Quarter...
					else if	(iWork3 >= int(_PlayWin->GetTileH() * 0.75))	{ _ptCursor.y -= 1; }
					else
					{
						//We don't have anything happen where all else fails...
						//This represents the center of the Tile that's meant
						//to be targeted by the User - M. White 15 March, 2019
					}
				}
				//Bottom Quarter...
				else if	(iWork4 >= int(_PlayWin->GetTileH() * 0.75))
				{
					//Left Quarter...
					if		(iWork3 <= int(_PlayWin->GetTileW() * 0.25))	{ _ptCursor.x -= 1; _ptCursor.y += 1; }
					//Right Quarter...
					else if	(iWork3 >= int(_PlayWin->GetTileH() * 0.75)) { _ptCursor.y += 1; }
					else
					{
						//We don't have anything happen where all else fails...
						//This represents the center of the Tile that's meant
						//to be targeted by the User - M. White 15 March, 2019
					}
				}
				else
				{
					//We don't have anything happen where all else fails...
					//This represents the center of the Tile that's meant
					//to be targeted by the User - M. White 15 March, 2019
				}
			}
			break;
		case SQR_Map:
			_ptCursor.x = int((_pEngine->GetMouseX() - _PlayWin->GetTileOffX()) / _PlayWin->GetTileW());
			_ptCursor.y = int((_pEngine->GetMouseY() - _PlayWin->GetTileOffY()) / _PlayWin->GetTileH());
			break;
		}
		_paintMainMap	= true;
		_paintSomething	= true;
		_ShowCursor		= true;
	}
	else _ShowCursor = false;    
}
void PaintSqrMap(HDC hDC)
{
	POINT ptTile, ptEdge;

	HBRUSH hB;	
	hB = CreateSolidBrush(RGB(0, 0, 0));
	FillRect(hDC, &_PlayWin->GetRect(), hB);
	DeleteObject(hB);

	int XStart = 0, Width	= 0;
	int	YStart = 0, Height	= 0;

	for(int y = 0; y < _PlayWin->GetScrnH(); y++)
		for(int x = 0; x < _PlayWin->GetScrnW(); x++)
		{
			ptTile.x = (x * _PlayWin->GetTileW()) + _PlayWin->GetTileOffX();
			ptTile.y = (y * _PlayWin->GetTileH()) + _PlayWin->GetTileOffY();

			//Did the tile fall completely into the Screen Map?
			if(ptTile.x > _PlayWin->gRectL() && (ptTile.x + _PlayWin->GetTileW()) < _PlayWin->gRectR() &&
			   ptTile.y > _PlayWin->gRectT() && (ptTile.y + _PlayWin->GetTileH()) < _PlayWin->gRectB())
			{
				_bmpTiles[SQR_Map].DrawPart(hDC, ptTile.x, ptTile.y, 
					int(_PlayWin->SqrScrn[x][y].GetBG() * _PlayWin->GetTileW()), 
					0, _PlayWin->GetTileW(), _PlayWin->GetTileH(), true); 
			}
			else
			{
				if		(ptTile.x < _PlayWin->gRectL())
				{
					ptEdge.x	= _PlayWin->gRectL();
					XStart		= int(_PlayWin->SqrScrn[x][y].GetBG() * _PlayWin->GetTileW()) + (_PlayWin->gRectL() - ptTile.x);
					Width		= _PlayWin->GetTileW() - (_PlayWin->gRectL() - ptTile.x);
				}
				else if	((ptTile.x + _PlayWin->GetTileW()) > _PlayWin->gRectR())
				{
					ptEdge.x	= ptTile.x;
					XStart		= int(_PlayWin->SqrScrn[x][y].GetBG() * _PlayWin->GetTileW());
					Width		= _PlayWin->gRectR() - ptTile.x;
				}
				else
				{
					ptEdge.x	= ptTile.x;
					XStart		= int(_PlayWin->SqrScrn[x][y].GetBG() * _PlayWin->GetTileW());
					Width		= _PlayWin->GetTileW();
				}
				//------------------------ Seperation of previous if-test sequence
				if		(ptTile.y < _PlayWin->gRectT())
				{
					ptEdge.y	= _PlayWin->gRectT();
					//These zeroes need to be modified later to account for bitmaps
					//that have multiple ranks of images to account for - M. White 15 March, 2019
					YStart		= 0 + (_PlayWin->gRectT() - ptTile.y);
					Height		= _PlayWin->GetTileH() - (_PlayWin->gRectT() - ptTile.y);
				}
				else if	((ptTile.y + _PlayWin->GetTileH()) > _PlayWin->gRectB())
				{
					ptEdge.y	= ptTile.y;
					//These zeroes need to be modified later to account for bitmaps
					//that have multiple ranks of images to account for - M. White 15 March, 2019
					YStart		= 0;
					Height		= _PlayWin->gRectB() - ptTile.y;
				}
				else
				{
					ptEdge.y	= ptTile.y;
					//These zeroes need to be modified later to account for bitmaps
					//that have multiple ranks of images to account for - M. White 15 March, 2019
					YStart		= 0;
					Height		= _PlayWin->GetTileH();
				}
				_bmpTiles[SQR_Map].DrawPart(hDC, ptEdge.x, ptEdge.y, XStart, YStart, Width, Height, true);
			}
		}

	if(_ShowCursor == true)
	{
		//This (y & 1) creates an boolen test - is Y even or odd?
		ptTile.x = _PlayWin->GetTileOffX() + (_ptCursor.x * _PlayWin->GetTileW());
		ptTile.y = _PlayWin->GetTileOffY() + (_ptCursor.y * _PlayWin->GetTileH());

		//Did the tile fall completely into the Screen Map?
		if(ptTile.x > _PlayWin->gRectL() && (ptTile.x + _PlayWin->GetTileW()) < _PlayWin->gRectR() &&
		   ptTile.y > _PlayWin->gRectT() && (ptTile.y + _PlayWin->GetTileH()) < _PlayWin->gRectB())
		{
			_bmpCursors->DrawPart(hDC, 
				ptTile.x, ptTile.y,							//Where will the cursor's x and y land?
				_PlayWin->GetType() * _PlayWin->GetTileW(), //Find x-source data by multiplying map type by width
				_bmpY,										//Move to y-source data determined at GameStart()
				_PlayWin->GetTileW(), _PlayWin->GetTileH(), //Width and Height of cursor matches Tile sizes...
				true);
		}
		else
		{
			if		(ptTile.x < _PlayWin->gRectL())
			{
				ptEdge.x	= _PlayWin->gRectL();
				XStart		= _PlayWin->GetType() * _PlayWin->GetTileW() + (_PlayWin->gRectL() - ptTile.x);
				Width		= _PlayWin->GetTileW() - (_PlayWin->gRectL() - ptTile.x);
			}
			else if	((ptTile.x + _PlayWin->GetTileW()) > _PlayWin->gRectR())
			{
				ptEdge.x	= ptTile.x;
				XStart		= _PlayWin->GetType() * _PlayWin->GetTileW();
				Width		= (_PlayWin->gRectR() + 1) - ptTile.x;
			}
			else
			{
				ptEdge.x	= ptTile.x;
				XStart		= _PlayWin->GetType() * _PlayWin->GetTileW();
				Width		= _PlayWin->GetTileW();
			}
			if		(ptTile.y < _PlayWin->gRectT())
			{
				ptEdge.y	= _PlayWin->gRectT();
				YStart		= _bmpY + (_PlayWin->gRectT() - ptTile.y);
				Height		= _PlayWin->GetTileH() - (_PlayWin->gRectT() - ptTile.y);
			}
			else if	((ptTile.y + _PlayWin->GetTileH()) > _PlayWin->gRectB())
			{
				ptEdge.y	= ptTile.y;
				YStart		= _bmpY;
				Height		= (_PlayWin->gRectB() + 1) - ptTile.y;
			}
			else
			{
				ptEdge.y	= ptTile.y;
				YStart		= _bmpY;
				Height		= _PlayWin->GetTileH();
			}
			_bmpCursors->DrawPart(hDC, ptEdge.x, ptEdge.y, XStart, YStart, Width, Height, true);
		}
	}
}
void PaintSqrIsoMap(HDC hDC)
{
	POINT ptTile, ptEdge;

	HBRUSH hB;	
	hB = CreateSolidBrush(RGB(0, 0, 0));
	FillRect(hDC, &_PlayWin->GetRect(), hB);
	DeleteObject(hB);

	int XStart = 0, Width	= 0;
	int	YStart = 0, Height	= 0;

	for(int y = 0; y < _PlayWin->GetScrnH(); y++)
		for(int x = 0; x < _PlayWin->GetScrnW(); x++)
		{
			//This (y & 1) creates an boolen test - is Y even or odd?
			ptTile.x = ((x * _PlayWin->GetTileW()) + ((y & 1) * int(_PlayWin->GetTileW() / 2))	- ((_SqrIsoY & 1) * int(_PlayWin->GetTileW() / 2))) + _PlayWin->GetTileOffX();
			ptTile.y = ((y * _PlayWin->GetTileH()) - ( y * int(_PlayWin->GetTileH() / 2)     )	- ((_SqrIsoY & 1) * int(_PlayWin->GetTileH() / 2))) + _PlayWin->GetTileOffY();

			//Did the tile fall completely into the Screen Map?
			if(ptTile.x > _PlayWin->gRectL() && (ptTile.x + _PlayWin->GetTileW()) < _PlayWin->gRectR() &&
			   ptTile.y > _PlayWin->gRectT() && (ptTile.y + _PlayWin->GetTileH()) < _PlayWin->gRectB())
			{
				_bmpTiles[DIA_Map].DrawPart(hDC, ptTile.x, ptTile.y,
					//The zero y-coordinate needs to be changed to a multiplier later to
					//account for multiple ranks of images - M. White 15 March, 2019
					(_PlayWin->SqrIsoScrn[x][y].GetBG() * _PlayWin->GetTileW()), 0,
					_PlayWin->GetTileW(), _PlayWin->GetTileH(), true);
			}
			//If the tile did not fall completely into the screen...clip it...
			else
			{
				if		(ptTile.x < _PlayWin->gRectL())
				{
					ptEdge.x	= _PlayWin->gRectL();
					XStart		= int(_PlayWin->SqrIsoScrn[x][y].GetBG() * _PlayWin->GetTileW()) + (_PlayWin->gRectL() - ptTile.x);
					Width		= _PlayWin->GetTileW() - (_PlayWin->gRectL() - ptTile.x);
				}
				else if	((ptTile.x + _PlayWin->GetTileW()) > _PlayWin->gRectR())
				{
					ptEdge.x	= ptTile.x;
					XStart		= int(_PlayWin->SqrIsoScrn[x][y].GetBG() * _PlayWin->GetTileW());
					Width		= _PlayWin->gRectR() - ptTile.x;
				}
				else
				{
					ptEdge.x	= ptTile.x;
					XStart		= int(_PlayWin->SqrIsoScrn[x][y].GetBG() * _PlayWin->GetTileW());
					Width		= _PlayWin->GetTileW();
				}
				if		(ptTile.y < _PlayWin->gRectT())
				{
					ptEdge.y	= _PlayWin->gRectT();
					//These zeroes need to be modified later to account for bitmaps
					//that have multiple ranks of images to account for - M. White 15 March, 2019
					YStart		= 0 + (_PlayWin->gRectT() - ptTile.y);
					Height		= _PlayWin->GetTileH() - (_PlayWin->gRectT() - ptTile.y);
				}
				else if	((ptTile.y + _PlayWin->GetTileH()) > _PlayWin->gRectB())
				{
					ptEdge.y	= ptTile.y;
					//These zeroes need to be modified later to account for bitmaps
					//that have multiple ranks of images to account for - M. White 15 March, 2019
					YStart		= 0;
					Height		= _PlayWin->gRectB() - ptTile.y;
				}
				else
				{
					ptEdge.y	= ptTile.y;
					//These zeroes need to be modified later to account for bitmaps
					//that have multiple ranks of images to account for - M. White 15 March, 2019
					YStart		= 0;
					Height		= _PlayWin->GetTileH();
				}
				_bmpTiles[DIA_Map].DrawPart(hDC, ptEdge.x, ptEdge.y, XStart, YStart, Width, Height, true);
			}
		}

	if(_ShowCursor == true)
	{
		ptTile.x = ((_ptCursor.x * _PlayWin->GetTileW()) + ((_ptCursor.y & 1) * 16) ) + _PlayWin->GetTileOffX();
		ptTile.y = ((_ptCursor.y * _PlayWin->GetTileH()) -  (_ptCursor.y * 16)	    ) + _PlayWin->GetTileOffY();

		//Did the tile fall completely into the Screen Map?
		if(ptTile.x > _PlayWin->gRectL() && (ptTile.x + _PlayWin->GetTileW()) < _PlayWin->gRectR() &&
			ptTile.y > _PlayWin->gRectT() && (ptTile.y + _PlayWin->GetTileH()) < _PlayWin->gRectB())
		{
			_bmpCursors->DrawPart(hDC, 
				ptTile.x, ptTile.y,							//Where will the cursor's x and y land?
				_PlayWin->GetType() * _PlayWin->GetTileW(), //Find x-source data by multiplying map type by width
				_bmpY,										//Move to y-source data determined at GameStart()
				_PlayWin->GetTileW(), _PlayWin->GetTileH(), //Width and Height of cursor matches Tile sizes...
				true);
		}
		else
		{
			if		(ptTile.x < _PlayWin->gRectL())
			{
				ptEdge.x	= _PlayWin->gRectL();
				XStart		= _PlayWin->GetType() * _PlayWin->GetTileW() + (_PlayWin->gRectL() - ptTile.x);
				Width		= _PlayWin->GetTileW() - (_PlayWin->gRectL() - ptTile.x);
			}
			else if	((ptTile.x + _PlayWin->GetTileW()) > _PlayWin->gRectR())
			{
				ptEdge.x	= ptTile.x;
				XStart		= _PlayWin->GetType() * _PlayWin->GetTileW();
				Width		= _PlayWin->gRectR() - ptTile.x;
			}
			else
			{
				ptEdge.x	= ptTile.x;
				XStart		= _PlayWin->GetType() * _PlayWin->GetTileW();
				Width		= _PlayWin->GetTileW();
			}
			if		(ptTile.y < _PlayWin->gRectT())
			{
				ptEdge.y	= _PlayWin->gRectT();
				YStart		= _bmpY + (_PlayWin->gRectT() - ptTile.y);
				Height		= _PlayWin->GetTileH() - (_PlayWin->gRectT() - ptTile.y);
			}
			else if	((ptTile.y + _PlayWin->GetTileH()) > _PlayWin->gRectB())
			{
				ptEdge.y	= ptTile.y;
				YStart		= _bmpY;
				Height		= _PlayWin->gRectB() - ptTile.y;
			}
			else
			{
				ptEdge.y	= ptTile.y;
				YStart		= _bmpY;
				Height		= _PlayWin->GetTileH();
			}
			_bmpCursors->DrawPart(hDC, ptEdge.x, ptEdge.y, XStart, YStart, Width, Height, true);
		}
	}
}
void PaintIsoMap(HDC hDC)
{
	POINT	ptTile, ptEdge;

	HBRUSH hB;	
	hB = CreateSolidBrush(RGB(0, 0, 0));
	FillRect(hDC, &_PlayWin->GetRect(), hB);
	DeleteObject(hB);

	int XStart = 0, Width	= 0;
	int	YStart = 0, Height	= 0;

	for(int y = 0; y < _PlayWin->GetScrnH(); y++)
		for(int x = 0; x < _PlayWin->GetScrnW(); x++)
		{
			//This (y & 1) creates an boolen test - is Y even or odd?
			ptTile.x = ((x * _PlayWin->GetTileW()) + ((y & 1) * int(_PlayWin->GetTileW() / 2))	- ((_IsoY & 1) * int(_PlayWin->GetTileW() / 2))) + _PlayWin->GetTileOffX();
			ptTile.y = ((y * _PlayWin->GetTileH()) - ( y * int(_PlayWin->GetTileH() / 2)      )	- ((_IsoY & 1) * int(_PlayWin->GetTileH() / 2))) + _PlayWin->GetTileOffY();

			//Did the tile fall completely into the Screen Map?
			if(ptTile.x > _PlayWin->gRectL() && (ptTile.x + _PlayWin->GetTileW()) < _PlayWin->gRectR() &&
			   ptTile.y > _PlayWin->gRectT() && (ptTile.y + _PlayWin->GetTileH()) < _PlayWin->gRectB())
			{
				_bmpTiles[RHO_Map].DrawPart(hDC, ptTile.x, ptTile.y,
					(_PlayWin->IsoScrn[x][y].GetBG() * _PlayWin->GetTileW()),
					0,
					_PlayWin->GetTileW(), _PlayWin->GetTileH(), true);
			}
			//If the tile did not fall completely into the screen...clip it...
			else
			{
				if		(ptTile.x < _PlayWin->gRectL())
				{
					ptEdge.x	= _PlayWin->gRectL();
					XStart		= int(_PlayWin->IsoScrn[x][y].GetBG() * _PlayWin->GetTileW()) + (_PlayWin->gRectL() - ptTile.x);
					Width		= _PlayWin->GetTileW() - (_PlayWin->gRectL() - ptTile.x);
				}
				else if	((ptTile.x + _PlayWin->GetTileW()) > _PlayWin->gRectR())
				{
					ptEdge.x	= ptTile.x;
					XStart		= int(_PlayWin->IsoScrn[x][y].GetBG() * _PlayWin->GetTileW());
					Width		= _PlayWin->gRectR() - ptTile.x;
				}
				else
				{
					ptEdge.x	= ptTile.x;
					XStart		= int(_PlayWin->IsoScrn[x][y].GetBG() * _PlayWin->GetTileW());
					Width		= _PlayWin->GetTileW();
				}
				if		(ptTile.y < _PlayWin->gRectT())
				{
					ptEdge.y	= _PlayWin->gRectT();
					//These zeroes need to be modified later to account for bitmaps
					//that have multiple ranks of images to account for - M. White 15 March, 2019
					YStart		= 0 + (_PlayWin->gRectT() - ptTile.y);
					Height		= _PlayWin->GetTileH() - (_PlayWin->gRectT() - ptTile.y);
				}
				else if	((ptTile.y + _PlayWin->GetTileH()) > _PlayWin->gRectB())
				{
					ptEdge.y	= ptTile.y;
					//These zeroes need to be modified later to account for bitmaps
					//that have multiple ranks of images to account for - M. White 15 March, 2019
					YStart		= 0;
					Height		= _PlayWin->gRectB() - ptTile.y;
				}
				else
				{
					ptEdge.y	= ptTile.y;
					//These zeroes need to be modified later to account for bitmaps
					//that have multiple ranks of images to account for - M. White 15 March, 2019
					YStart		= 0;
					Height		= _PlayWin->GetTileH();
				}
				_bmpTiles[RHO_Map].DrawPart(hDC, ptEdge.x, ptEdge.y, XStart, YStart, Width, Height, true);
			}
		}

	if(_ShowCursor == true)
	{
			ptTile.x = ((_ptCursor.x * _PlayWin->GetTileW()) + ((_ptCursor.y & 1) * 16) ) + _PlayWin->GetTileOffX();
			ptTile.y = ((_ptCursor.y * _PlayWin->GetTileH()) -  (_ptCursor.y * 8)	    ) + _PlayWin->GetTileOffY();

		//Did the tile fall completely into the Screen Map?
		if(ptTile.x > _PlayWin->gRectL() && (ptTile.x + _PlayWin->GetTileW()) < _PlayWin->gRectR() &&
		   ptTile.y > _PlayWin->gRectT() && (ptTile.y + _PlayWin->GetTileH()) < _PlayWin->gRectB())
		{			
			_bmpCursors->DrawPart(hDC, 
				ptTile.x, ptTile.y,							//Where will the cursor's x and y land?
				_PlayWin->GetType() * _PlayWin->GetTileW(), //Find x-source data by multiplying map type by width
				_bmpY,										//Move to y-source data determined at GameStart()
				_PlayWin->GetTileW(), _PlayWin->GetTileH(), //Width and Height of cursor matches Tile sizes...
				true);
		}
		else
		{
			if		(ptTile.x < _PlayWin->gRectL())
			{
				ptEdge.x	= _PlayWin->gRectL();
				XStart		= _PlayWin->GetType() * _PlayWin->GetTileW() + (_PlayWin->gRectL() - ptTile.x);
				Width		= _PlayWin->GetTileW() - (_PlayWin->gRectL() - ptTile.x);
			}
			else if	((ptTile.x + _PlayWin->GetTileW()) > _PlayWin->gRectR())
			{
				ptEdge.x	= ptTile.x;
				XStart		= _PlayWin->GetType() * _PlayWin->GetTileW();
				Width		= _PlayWin->gRectR() - ptTile.x;
			}
			else
			{
				ptEdge.x	= ptTile.x;
				XStart		= _PlayWin->GetType() * _PlayWin->GetTileW();
				Width		= _PlayWin->GetTileW();
			}
			if		(ptTile.y < _PlayWin->gRectT())
			{
				ptEdge.y	= _PlayWin->gRectT();
				YStart		= _bmpY + (_PlayWin->gRectT() - ptTile.y);
				Height		= _PlayWin->GetTileH() - (_PlayWin->gRectT() - ptTile.y);
			}
			else if	((ptTile.y + _PlayWin->GetTileH()) > _PlayWin->gRectB())
			{
				ptEdge.y	= ptTile.y;
				YStart		= _bmpY;
				Height		= _PlayWin->gRectB() - ptTile.y;
			}
			else
			{
				ptEdge.y	= ptTile.y;
				YStart		= _bmpY;
				Height		= _PlayWin->GetTileH();
			}
			_bmpCursors->DrawPart(hDC, ptEdge.x, ptEdge.y, XStart, YStart, Width, Height, true);
		}
	}
}
void PaintHexMap(HDC hDC)
{
	POINT ptTile, ptEdge;

	HBRUSH hB; hB = CreateSolidBrush(RGB(0, 0, 0));
	FillRect(hDC, &_PlayWin->GetRect(), hB);
	DeleteObject(hB);

	int XStart = 0, Width	= 0;
	int	YStart = 0, Height	= 0;

	for(int y = 0; y < _PlayWin->GetScrnH(); y++)
		for(int x = 0; x < _PlayWin->GetScrnW(); x++)
		{
			//This (y & 1) creates an boolen test - is Y even or odd?
			ptTile.x = ((x * _PlayWin->GetTileW()) + ((y & 1) * int(_PlayWin->GetTileW() / 2))	- ((_HexY & 1) * int(_PlayWin->GetTileW() / 2))) + _PlayWin->GetTileOffX();
			ptTile.y = ((y * _PlayWin->GetTileH()) - ( y * int(_PlayWin->GetTileH() / 2)     )	- ((_HexY & 1) * int(_PlayWin->GetTileH() / 2))) + _PlayWin->GetTileOffY();

			//Did the tile fall completely into the Screen Map?
		//	if(ptTile.x > _PlayWin->gRectL() && (ptTile.x + _PlayWin->GetTileW()) < _PlayWin->gRectR() &&
		//	   ptTile.y > _PlayWin->gRectT() && (ptTile.y + _PlayWin->GetTileH()) < _PlayWin->gRectB())
		//	{
					_bmpTiles[HEX_Map01].DrawPart(hDC, ptTile.x, ptTile.y,
					//The Starting-Y coordinate (30), needs to be converted to a multiplier 
					//that accounts for multiple ranks of images...
					//Also, the value 32 for the x- coordinates needs to coordinate with the 
					//PlayWindow class data about Hexagons. They all should match how the 
					//actual graphic is painted (aka, 32 x 30 pixels) - M. White 15 March, 2019
					_PlayWin->HexScrn[x][y].GetBG() * 32,  30, 32, _PlayWin->GetTileH(), true);
		/*	}
			//If the tile did not fall completely into the screen...clip it...
			else
			{
				if		(ptTile.x < _PlayWin->gRectL())
				{
					ptEdge.x	= _PlayWin->gRectL();
					XStart		= int(_PlayWin->HexScrn[x][y].GetBG() * 32) + (_PlayWin->gRectL() - ptTile.x);
					Width		= 32 - (_PlayWin->gRectL() - ptTile.x);
				}
				else if	((ptTile.x + 32) > _PlayWin->gRectR())
				{
					ptEdge.x	= ptTile.x;
					XStart		= int(_PlayWin->HexScrn[x][y].GetBG() * 32);
					Width		= (_PlayWin->gRectR() + 1) - ptTile.x;
				}
				else
				{
					ptEdge.x	= ptTile.x;
					XStart		= int(_PlayWin->HexScrn[x][y].GetBG() * 32);
					Width		= 32;
				}
				if		(ptTile.y < _PlayWin->gRectT())
				{
					ptEdge.y	= _PlayWin->gRectT();
					//These zeroes (30s) need to be modified later to account for bitmaps
					//that have multiple ranks of images to account for - M. White 15 March, 2019
					YStart		= 30 + (_PlayWin->gRectT() - ptTile.y);
					Height		= 30 - (_PlayWin->gRectT() - ptTile.y);
				}
				else if	((ptTile.y + _PlayWin->GetTileH()) > _PlayWin->gRectB())
				{
					ptEdge.y	= ptTile.y;
					//These zeroes (30s) need to be modified later to account for bitmaps
					//that have multiple ranks of images to account for - M. White 15 March, 2019
					YStart		= 30;
					Height		= (_PlayWin->gRectB() + 1) - ptTile.y;
				}
				else
				{
					ptEdge.y	= ptTile.y;
					//These zeroes (30s) need to be modified later to account for bitmaps
					//that have multiple ranks of images to account for - M. White 15 March, 2019
					YStart		= 30;
					Height		= 30;
				}
				_bmpTiles[HEX_Map].DrawPart(hDC, ptEdge.x, ptEdge.y, XStart, YStart, Width, Height, true);
			}*/
		}

	if(_ShowCursor == true)
	{
		//This (y & 1) creates an boolen test - is Y even or odd?
		ptTile.x = ((_ptCursor.x * _PlayWin->GetTileW()) + ((_ptCursor.y & 1) * 24)	- ((_HexY & 1) * 24)) + _PlayWin->GetTileOffX();
		ptTile.y = ((_ptCursor.y * _PlayWin->GetTileH()) -  (_ptCursor.y * 15)		- ((_HexY & 1) * 15)) + _PlayWin->GetTileOffY();
		//Did the tile fall completely into the Screen Map?
		if(ptTile.x > _PlayWin->gRectL() && (ptTile.x + _TileW_Hex) < _PlayWin->gRectR() &&
		   ptTile.y > _PlayWin->gRectT() && (ptTile.y + _TileH_Hex) < _PlayWin->gRectB())
		{
			_bmpCursors->DrawPart(hDC, ptTile.x, ptTile.y, _PlayWin->GetType() * _TileW_Hex, _bmpY, _TileW_Hex, _TileH_Hex, true);
			
		//	_bmpCursors->DrawPart(hDC, 
		//		ptTile.x, ptTile.y,							//Where will the cursor's x and y land?
		//		_PlayWin->GetType() * _PlayWin->GetTileW(), //Find x-source data by multiplying map type by width
		//		_bmpY,										//Move to y-source data determined at GameStart()
		//		_PlayWin->GetTileW(), _PlayWin->GetTileH(), //Width and Height of cursor matches Tile sizes...
		//		true);
		}
		else
		{
			if		(ptTile.x < _PlayWin->gRectL())
			{
				ptEdge.x	= _PlayWin->gRectL();
				XStart		= _PlayWin->GetType() * _TileW_Hex + (_PlayWin->gRectL() - ptTile.x);
				Width		= _TileW_Hex - (_PlayWin->gRectL() - ptTile.x);
			}
			else if	((ptTile.x + _TileW_Hex) > _PlayWin->gRectR())
			{
				ptEdge.x	= ptTile.x;
				XStart		= _PlayWin->GetType() * _TileW_Hex;
				Width		= _PlayWin->gRectR() - ptTile.x;
			}
			else
			{
				ptEdge.x	= ptTile.x;
				XStart		= _PlayWin->GetType() * _TileW_Hex;
				Width		= _TileW_Hex;
			}
			if		(ptTile.y < _PlayWin->gRectT())
			{
				ptEdge.y	= _PlayWin->gRectT();
				YStart		= _bmpY + (_PlayWin->gRectT() - ptTile.y);
				Height		= _TileH_Hex - (_PlayWin->gRectT() - ptTile.y);
			}
			else if	((ptTile.y + _TileH_Hex) > _PlayWin->gRectB())
			{
				ptEdge.y	= ptTile.y;
				YStart		= _bmpY;
				Height		= _PlayWin->gRectB() - ptTile.y;
			}
			else
			{
				ptEdge.y	= ptTile.y;
				YStart		= _bmpY;
				Height		= _TileH_Hex;
			}
			_bmpCursors->DrawPart(hDC, ptEdge.x, ptEdge.y, XStart, YStart, Width, Height, true);
		}
	}
}