puzzlebmp.cpp

网络游戏魔域源代码 测试可以完整变异

//------------------------------------------------
// PuzzleBmp.cpp
//------------------------------------------------
#include "PuzzleBmp.h"
#include "GameDataSet.h"
#include "3DGameMap.h"
#include "Physics.h"

int CPuzzleBmp::s_nRectAmount = 0;
CMyRect	CPuzzleBmp::s_setRect[_MAX_DIRTY_RECT]; 

//------------------------------------------------
CPuzzleBmp::CPuzzleBmp()
{
	m_usPuzzleIndex = NULL;
	m_nPuzzleAmount = 0;
	this->Destroy();
	strcpy(m_szAniFile, "");
	m_nZoomInNum = 1;
	m_nGrideSize = PUZZLE_GRIDE_SIZE;
	m_bTerrain = true;
	m_nRollSpeedX	= 0;
	m_nRollSpeedY	= 0;
	m_dwTimeBegin	= ::TimeGet();
	m_nMoveRateX	= 100;
	m_nMoveRateY	= 100;
	m_bRoll			= true;
	m_dwTimer		= ::TimeGet();
	m_dwColor		= 0xffffffff;
}
//------------------------------------------------
CPuzzleBmp::~CPuzzleBmp()
{
	this->Destroy();
}

//------------------------------------------------
void CPuzzleBmp::Destroy()
{
	if(m_usPuzzleIndex)
		delete[] m_usPuzzleIndex; 
	m_usPuzzleIndex = NULL;
	m_nPuzzleAmount = 0;
//	if(strlen(m_szAniFile) != NULL)
//		CAni::s_setAniFile.DelAniFile(m_szAniFile);
}
//------------------------------------------------
void CPuzzleBmp::SetSize(CMySize infoSize)
{
	this->Destroy();
	int nAmount = infoSize.iWidth * infoSize.iHeight;
	m_infoSize = infoSize;
	m_usPuzzleIndex = new unsigned short[nAmount];
	for(int i = 0; i < nAmount; i++)
	{
		unsigned short* pusIndex = m_usPuzzleIndex + i;
		*pusIndex = 65535;
	}
	m_nPuzzleAmount = nAmount;
}
//------------------------------------------------
void CPuzzleBmp::Show(int iPosX, int iPosY, BOOL bGrid, BOOL bPos)
{
//	bPos = bGrid = true;
	DWORD dwFrame = (::TimeGet()-m_dwTimer)/160;
	BOOL bRollBack = true;
	if((m_nRollSpeedX == 0) && 
		(m_nRollSpeedY == 0))
	{
		bRollBack = false;
	}
	if(!m_bRoll)
		bRollBack = false;

	CMySize sizeBmp;
	this->GetSize(sizeBmp);
	if(bRollBack)
	{
		CMyPos posOffset;
		DWORD dwTimeCurrent = ::TimeGet();
		posOffset.x = m_nRollSpeedX * m_nMoveRateX * (dwTimeCurrent - m_dwTimeBegin)/(1000 * 100);
		posOffset.y = m_nRollSpeedY * m_nMoveRateY * (dwTimeCurrent - m_dwTimeBegin)/(1000 * 100);

		iPosX += posOffset.x;
		iPosY += posOffset.y;
		iPosX = iPosX%(int)sizeBmp.iWidth;
		iPosY = iPosY%(int)sizeBmp.iHeight;
	}
	if(m_bTerrain)
		s_nRectAmount = 0;

	this->PreLoad(iPosX, iPosY);
	CMyPos posCell;
	posCell.x = -iPosX/m_nGrideSize;
	posCell.y = -iPosY/m_nGrideSize;
	if(iPosX>0)
		posCell.x --;
	if(iPosY>0)
		posCell.y --;

	CMySize infoSize;
	this->GetSizeByGride(infoSize);

	int nRealGridrSize = m_nGrideSize*g_objGameMap.GetScale()/_NORMAL_SCALE;
	
	int nAddPuzzleX = PUZZLE_SCRX/m_nGrideSize - PUZZLE_SCRX/nRealGridrSize;
	int nAddPuzzleY = PUZZLE_SCRY/m_nGrideSize - PUZZLE_SCRY/nRealGridrSize;

	int nAmountX = PUZZLE_SCRX/nRealGridrSize+3;
	int nAmountY = PUZZLE_SCRY/nRealGridrSize+3;
	CMyPos posView;
	posView.x  =  iPosX + posCell.x*m_nGrideSize;
	posView.y  =  iPosY + posCell.y*m_nGrideSize;
	if(nRealGridrSize > m_nGrideSize)
	{
		nAmountX += nAddPuzzleX;
		nAmountY += nAddPuzzleY;

		nAddPuzzleX = nAddPuzzleY = 0;
	}
	if(nRealGridrSize < m_nGrideSize)
	{
		nAmountX += nAddPuzzleX+1;
		nAmountY += nAddPuzzleY+1;

		nAddPuzzleX = nAddPuzzleY = -1;
	}
	
	for(int i = nAddPuzzleX; i < nAmountY; i++)
	{
		for(int j = nAddPuzzleY; j< nAmountX; j++)
		{
			CMyPos posCellShow;
			posCellShow.x = posCell.x + j;
			posCellShow.y = posCell.y + i;
			if(posCellShow.x < 0)
			{
				if(!bRollBack)
					continue;
				else
					posCellShow.x += infoSize.iWidth;
			}
			if(posCellShow.y < 0)
			{
				if(!bRollBack)
					continue;
				else
					posCellShow.y += infoSize.iHeight;
			}
			
			
			if(posCellShow.x >= infoSize.iWidth)
			{
				if(!bRollBack)
					continue;
				else
					posCellShow.x -= infoSize.iWidth;

			}
			if(posCellShow.y >= infoSize.iHeight)
			{
				if(!bRollBack)
					continue;
				else
					posCellShow.y -= infoSize.iHeight;
			}
			
			CMyPos posShow;
			posShow.x = posView.x + j*m_nGrideSize;
			posShow.y = posView.y + i*m_nGrideSize;
	
			g_objGameMap.MapScaleShowPos(posShow.x, posShow.y);
			int nIndex = this->GetGrid(posCellShow.x, posCellShow.y);
			
			if(nIndex == 65535)
			{
				// 透明
				if(bGrid)
				{
					CMyBitmap::ShowRect(posShow.x, posShow.y, 
						posShow.x + m_nGrideSize, posShow.y + m_nGrideSize, 0xffffff00); 
				}
				if(bPos)
				{
					char szPos[64];
					sprintf(szPos, "【%d,%d】", posCellShow.x, posCellShow.y);
					CMySize sizeFont;
					CMyBitmap::GetFontSize(sizeFont);
					CMyBitmap::ShowString(posShow.x, posShow.y, 0xffffff, szPos);
				}
			}
			else
			{
				char szTitle[64];
				sprintf(szTitle, "Puzzle%d", nIndex);
				CAni* pAni = g_objGameDataSet.GetDataAni(m_szAniFile, szTitle, EXIGENCE_IMMEDIATE, g_objGameDataSet.m_dwPuzzleLife);
				if(pAni)
				{
					CMyBitmap* pBmp = pAni->GetFrame(0);
					if(pBmp)
					{
						DWORD dwARGB = m_dwColor;
						unsigned char ucA, ucR, ucG, ucB;
						ucA = dwARGB >> 24;
						ucR = (dwARGB & 0x00ff0000) >> 16;
						ucG = (dwARGB & 0x0000ff00) >> 8;
						ucB = dwARGB & 0x000000ff;
						pBmp->SetColor(ucA, ucR, ucG, ucB);
					}
					if(m_bTerrain)
					{
						CMyRect rect;
						rect.l = posShow.x;
						rect.t = posShow.y;
						rect.r = posShow.x + nRealGridrSize;
						rect.b = posShow.y + nRealGridrSize;
						this->TestRect(rect, true, pBmp->IsbTransparentFormat());
						
						pAni->ShowEx(dwFrame, posShow.x, posShow.y, NULL, nRealGridrSize, nRealGridrSize);
					}
					else
					{	
						CMyRect rect;
						rect.l = posShow.x;
						rect.t = posShow.y;
						rect.r = posShow.x + nRealGridrSize;
						rect.b = posShow.y + nRealGridrSize;
						if(this->TestRect(rect, false, pBmp->IsbTransparentFormat()))
							pAni->ShowEx(dwFrame, posShow.x, posShow.y, NULL, nRealGridrSize, nRealGridrSize);
						else
							int ll = 0;
					}

					if(bGrid)
					{
						CMyBitmap::ShowRect(posShow.x, posShow.y, 
									posShow.x + m_nGrideSize, posShow.y + nRealGridrSize, 0xffffff00); 
					}
					if(bPos)
					{
						char szPos[64];
						sprintf(szPos, "【%d,%d,%d】", posCellShow.x, posCellShow.y, nIndex);
						CMySize sizeFont;
						CMyBitmap::GetFontSize(sizeFont);
						CMyBitmap::ShowString(posShow.x, posShow.y, 0xffffff00, szPos);
					}
				}
				else
				{
					// 无图片资源
					CMyBitmap::ShowBlock(posShow.x, posShow.y, 
						posShow.x + m_nGrideSize, posShow.y + nRealGridrSize, 0xffffff00, 0xffffff00, 0xffffff00, 0xffffff00); 
					CMyBitmap::ShowRect(posShow.x, posShow.y, 
						posShow.x + m_nGrideSize, posShow.y + nRealGridrSize, 0xffffff00); 
				}
			}
			
		}
	}
	
}
//------------------------------------------------
void CPuzzleBmp::SetGrid(int iPosX, int iPosY, unsigned short usIndex)
{
	CMyPos posGrid;
	posGrid.x = -iPosX/m_nGrideSize;
	posGrid.y = -iPosY/m_nGrideSize;
	unsigned short* pusIndex = m_usPuzzleIndex + posGrid.y*m_infoSize.iWidth +posGrid.x;
	*pusIndex = usIndex;
}
//------------------------------------------------
unsigned short CPuzzleBmp::GetGrid(CMyPos posShow)
{
	CMyPos posGrid;
	posGrid.x = -posShow.x/m_nGrideSize;
	posGrid.y = -posShow.y/m_nGrideSize;
	return this->GetGrid(posGrid.x, posGrid.y);
}
//------------------------------------------------

BOOL CPuzzleBmp::Load(char* pszFile)
{
	if(!pszFile)
		return false;
	
	FILE* fp = fopen(pszFile, "rb");
	if(!fp)
		return false;
	// header..(8 bytes)
	char szHeader[8]="";
	fread(szHeader, 1, 8, fp);
	// check header ...
	m_dwVersion = 0;
	if(strcmp(szHeader, "PUZZLE") == 0)
		m_dwVersion = 1;
	else
	{
		if(strcmp(szHeader, "PUZZLE2") == 0)
			m_dwVersion = 2;
	}
	
	if(m_dwVersion == 0)
	{
		fclose(fp);
		return false;
	}
	// AniFile.. (256 bytes)
	char szAni[256];
	fread(szAni, 1, 256, fp);
	this->SetAniFile(szAni);
	// Size...
	CMySize infoSize;
	fread(&infoSize.iWidth, sizeof(UINT), 1, fp);
	fread(&infoSize.iHeight, sizeof(UINT), 1, fp);
	this->SetSize(infoSize);
	
	// Grid...
/*	int nAmount = infoSize.iWidth*infoSize.iHeight;
	m_setAniInfo.clear();