ani.cpp

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

	if(uFrame+1 >= m_iFrameAmount)
		return true;
	else
		return false;
}

//--------------------------------------------------------------
CMyBitmap* CAni::GetFrame(UINT uFrameIndex) const 
{
	if(m_nStatus != ANISTATUS_LOADED || m_iFrameAmount <= 0)
		return NULL;

	return m_pbmpFrame[uFrameIndex%m_iFrameAmount];
}

//--------------------------------------------------------------
void CAni::Destroy(void)
{
	if(m_nStatus != ANISTATUS_LOADED)
		return;

	for(int i=0;i<m_iFrameAmount;i++)
	{
		if(m_bHalf)
		{
			if((i == 0)||(i%2 != 0))						
	            SAFE_DELETE(m_pbmpFrame[i]);
		}
		else
		{		
            SAFE_DELETE(m_pbmpFrame[i]);
		}
        
		m_pbmpFrame[i]	=NULL;
	}

	m_iFrameAmount	=0;
	m_nStatus	=ANISTATUS_INIT;

	return;
}

//--------------------------------------------------------------
DWORD CAni::GetSize() const 
{
	DWORD dwAniSize = 0;
	if(m_nStatus == ANISTATUS_LOADED)
	{
		int nAmount = this->GetFrameAmount();
		for(int i = 0; i < nAmount; i ++)
		{
			if(m_bHalf)
			{
				if((i != 0)&&(i%2 == 0))
					continue;
			}

			CMyBitmap* pBmp = this->GetFrame(i);
			if(pBmp)
				dwAniSize += pBmp->GetSize();
		}
	}
	return dwAniSize;
}

//--------------------------------------------------------------
CMySize CAni::GetSize(UINT uFrame) const
{
	CMySize sizeAni = {0, 0};
	CMyBitmap* pBmp = this->GetFrame(uFrame);
	if(pBmp)
	{
		pBmp->GetSize(sizeAni.iWidth, sizeAni.iHeight);
	}
	return sizeAni;
}

//--------------------------------------------------------------
BOOL CAni::CheckAni(const char* pszDataFile, const char* pszIndex)
{
	// param check
	if (!pszDataFile || !pszIndex)
		return false;

	// open data file
	FILE* fp	=fopen(pszDataFile, "r");
	if (!fp)
		return false;

	// search the titile
	char szTitle[256];
	sprintf(szTitle, "[%s]", pszIndex);

	while(true)
	{
		char szLine[1024];
		if (EOF == fscanf(fp, "%s\n", szLine))
		{
			fclose(fp);
			return false;
		}
		
		if (strstr(szLine, szTitle))
		{
			fclose(fp);
			return true;
		}
	}
}

//--------------------------------------------------------------
//	CDynamicAni
//--------------------------------------------------------------
CDynamicAni::CDynamicAni(const char* pszIniFile, const char* pszIndex, BOOL bHalf)
{
	m_bHalf = bHalf;
	m_dwTimeBorn = ::TimeGet();
	this->SetAniFilename(pszIniFile, pszIndex);
}


//--------------------------------------------------------------
BOOL CDynamicAni::Load(void)
{
	try {
		this->ResetLife();
		return this->Create(m_szIniFile, m_szIndex, m_bHalf);
	}
	catch(...)
	{
		::LogMsg("Error: exception catch when loading %s :%s", m_szIniFile, m_szIndex);
		return false;
	}
}

BOOL CDynamicAni::SetAniFilename(const char *pszDataFile, const char *pszIndex)
{
	if(!pszDataFile || !pszIndex)
		return false;
	strcpy(m_szIniFile, pszDataFile);
	strcpy(m_szIndex, pszIndex);
	
	static char szTmep[256];
	strcpy(szTmep, pszDataFile);
	strcat((char*)szTmep, pszIndex);
	m_idAni = Str2ID(szTmep);
	return true;
}

BOOL CDynamicAni::CheckAniByFilename(const char *pszDataFile, const char *pszIndex) const
{
	if(!pszDataFile || !pszIndex)
		return false;

	if((strcmp(pszIndex, m_szIndex) == 0) &&
		(strcmp(pszDataFile, m_szIniFile) == 0))
		return true;

	return false;
}

//#########################################################################

//--------------------------------------------------------------
CAniFile::CAniFile()
{
}
//--------------------------------------------------------------
CAniFile::~CAniFile()
{
	this->Destroy();
}
//--------------------------------------------------------------
void CAniFile::Destroy()
{
	map<OBJID, AniIndexInfo>::iterator iter;
	for(iter = m_setAniIndexInfo.begin(); iter != m_setAniIndexInfo.end();  iter++)
		this->DestroyAniIndexInfo(iter->second);
	m_setAniIndexInfo.clear();
}
//--------------------------------------------------------------
AniIndexInfo* CAniFile::CreateNewAniIndexInfo()
{
	AniIndexInfo* pInfo = new AniIndexInfo;
	MYASSERT(pInfo);
	return pInfo;
}
//--------------------------------------------------------------
void CAniFile::DestroyAniIndexInfo(AniIndexInfo& pInfo)
{
	int nAmount = pInfo.setAniLine.size();
	for(int i = nAmount-1; i >= 0; i--)
	{
		char* pszStr = pInfo.setAniLine[i];
		if(pszStr)
		{
			delete[] pszStr;
			pszStr = NULL;
		}
	}
	pInfo.setAniLine.clear();
}
//--------------------------------------------------------------
CAniFile* CAniFile::CreateNew(char* pszAniFile)
{
	if(!pszAniFile)
		return NULL;
	CAniFile* pAniFile = new CAniFile;
	MYASSERT(pAniFile);
	
	if(!pAniFile->Create(pszAniFile))
	{
		SAFE_DELETE(pAniFile);
		return NULL;
	}
	strcpy(pAniFile->m_szFileName, pszAniFile);
	return pAniFile;
}
//--------------------------------------------------------------
BOOL CAniFile::Create(char* pszAniFile)
{
	if(!pszAniFile)
		return false;

	FILE* fp = fopen(pszAniFile, "r");
	if(!fp)
		return false;
	
	while(true)
	{
		// scan title
		char szLine[1024] = "";
		if(EOF == fscanf(fp, "%s\n", szLine))
		{
			fclose(fp);
			return true;
		}

		char szTitle[MAX_PATH] = "";
		if (1 != sscanf(szLine, "[%s", szTitle))
			continue;

		char* p =strchr(szTitle, ']');
		if (p)
			*p = '\0';
		else
		{
			fclose(fp);

			::ErrorOut("Error Title line %s in %s", szLine, pszAniFile);
			return false;
		}
 
		AniIndexInfo infoAni;
		this->AddAniIndexLine(&infoAni, szTitle);

		// get frame amount
		int nFrameAmount = 0;
		if (1 != fscanf(fp, "FrameAmount=%d\n", &nFrameAmount))
		{
			fclose(fp);

			::ErrorOut("FrameAmount error in [%s] of %s", szTitle, pszAniFile);
			return false;
		}

		nFrameAmount %= _MAX_FRAME;

		// get frame file name
		for (int i=0; i<nFrameAmount; i++)
		{
			char szFormat[MAX_PATH] = "";
			sprintf(szFormat, "Frame%d=%s\n", i, "%s");
		
			char szFile[MAX_PATH] = "";
			if (1 != fscanf(fp, szFormat, szFile))
			{
				fclose(fp);

				::ErrorOut("%s error in [%s] of %s", szFormat, szTitle, pszAniFile);
				return false;
			}

			// yeah
			this->AddAniIndexLine(&infoAni, szFile);
		}
		OBJID id  = Str2ID(szTitle);
		m_setAniIndexInfo[id] = infoAni;
	}
	return true;
}
//--------------------------------------------------------------
AniIndexInfo* CAniFile::GetAniIndexInfo(char* pszIndex)
{
	if(!pszIndex)
		return NULL;
	OBJID id = Str2ID(pszIndex);
	map<OBJID, AniIndexInfo>::iterator iter = m_setAniIndexInfo.find(id);
	if (iter == m_setAniIndexInfo.end())
	{
		return NULL;
	}
	return &iter->second;
}
//--------------------------------------------------------------
void CAniFile::AddAniIndexLine(AniIndexInfo* pInfo, char* pszLine)
{
	if(!pInfo || !pszLine)
		return;
	char* pszStr = new char[strlen(pszLine)+1];
	strcpy(pszStr, pszLine);
	pInfo->setAniLine.push_back(pszStr);
}
//--------------------------------------------------------------

//#########################################################################

//--------------------------------------------------------------
CAniFileSet::CAniFileSet()
{
}
//--------------------------------------------------------------
CAniFileSet::~CAniFileSet()
{
	this->Destroy();
}
//--------------------------------------------------------------
void CAniFileSet::Destroy()
{
	int nAmount = m_setAniFile.size();
	for(int i = 0; i < nAmount; i++)
	{
		SAFE_DELETE(m_setAniFile[i]);
	}
	m_setAniFile.clear();
}
//--------------------------------------------------------------
void CAniFileSet::AddAniFile(char* pszAniFile)
{
	if(!pszAniFile)
		return;
	int nAmount = m_setAniFile.size();
	for(int i = 0; i < nAmount; i++)
	{
		CAniFile* pFile = m_setAniFile[i];
		if(pFile && (strcmp(pFile->m_szFileName, pszAniFile) == 0))
			return;
	}
	CAniFile* pFile = CAniFile::CreateNew(pszAniFile);
	if(pFile)
		m_setAniFile.push_back(pFile);
}
//--------------------------------------------------------------
void CAniFileSet::DelAniFile(char* pszAniFile)
{
	if(!pszAniFile)
		return;
	int nAmount = m_setAniFile.size();
	for(int i = 0; i < nAmount; i++)
	{
		CAniFile* pFile = m_setAniFile[i];
		if(pFile && (strcmp(pFile->m_szFileName, pszAniFile) == 0))
		{
			SAFE_DELETE(pFile);
			m_setAniFile.erase(m_setAniFile.begin()+i);
			return;
		}
	}
}
//--------------------------------------------------------------
AniIndexInfo* CAniFileSet::GetAniIndexInfo(char* pszAniFile, char* pszAniIndex)
{
	if(!pszAniFile || !pszAniIndex)
		return NULL;
	int nAmount = m_setAniFile.size();
	for(int i = 0; i < nAmount; i++)
	{
		CAniFile* pFile = m_setAniFile[i];
		if(pFile && (strcmp(pFile->m_szFileName, pszAniFile) == 0))
		{
			return pFile->GetAniIndexInfo(pszAniIndex);
		}
	}
	return NULL;
} 
//--------------------------------------------------------------