anifile.cpp

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

//--------------------------------------------------------------------------------------
// File Name: AniFile.cpp
// Create by: Huang Yuhang
// Create on: 2003/9/24 14:40
//--------------------------------------------------------------------------------------
#pragma warning(disable:4786)
#include "AniFile.h"
#include "DataAniModule.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CAniFile::CAniFile()
{
	m_pAniFile = NULL;
	m_pDaiFile = NULL;
	m_pAniFileByOrder = NULL;
	m_pDaiFileByOrder = NULL;
	m_uLastErrorLine = 0;
}

CAniFile::~CAniFile()
{
	this->Clear();
}

//--------------------------------------------------------------------------------------

unsigned long	CAniFile::Str2Id(const char* pszStr)
{
	int i;
	unsigned int v;
	strncpy((char *)m_idGen,pszStr,256);
	for (i=0;i<256/4 && m_idGen[i];i++) ;
	m_idGen[i++]=0x9BE74448,m_idGen[i++]=0x66F42C48;
	v=0xF4FA8928;
	unsigned* pm = (unsigned*)&m_idGen;
	__asm {
		mov esi,0x37A8470E		;x0=0x37A8470E
			mov edi,0x7758B42B		;y0=0x7758B42B
			xor ecx,ecx
_loop:
		mov ebx,0x267B0B11		;w=0x267B0B11
			rol v,1
			mov eax,pm
			xor ebx,v
			
			mov eax,[eax+ecx*4]
			mov edx,ebx
			xor esi,eax
			xor edi,eax
			
			add edx,edi
			or edx,0x2040801		;a=0x2040801
			and edx,0xBFEF7FDF		;c=0xBFEF7FDF
			
			mov eax,esi
			mul edx
			adc eax,edx
			mov edx,ebx
			adc eax,0
			
			add edx,esi
			or edx,0x804021			;b=0x804021
			and edx,0x7DFEFBFF		;d=0x7DFEFBFF
			
			mov esi,eax
			mov eax,edi
			mul edx
			
			add edx,edx
			adc eax,edx
			jnc _skip
			add eax,2
_skip:
		inc ecx;
		mov edi,eax
			cmp ecx,i
			jnz _loop
			xor esi,edi
			mov v,esi
	}
	return v;
}

//--------------------------------------------------------------------------------------
void CAniFile::Clear()
{
	if(m_pAniFile)
	{
		map<unsigned long, AniInfo*>::iterator iter = m_pAniFile->setAniInfo.begin();
		while(iter != m_pAniFile->setAniInfo.end())
		{
			AniInfo* pInfo = iter->second;
			if(pInfo)
			{
				int nStrAmounat = pInfo->setFrame.size();
				for(int i = 0; i < nStrAmounat; i++)
				{
					char* pStr = pInfo->setFrame[i];
					if(pStr)
						delete[] pStr;
				}
				pInfo->setFrame.clear();
				delete(pInfo);
				pInfo = NULL;
			}
			iter ++;
		}
		m_pAniFile->setAniInfo.clear();
		delete m_pAniFile;
		m_pAniFile = NULL;
	}

	if(m_pDaiFile)
	{
		map<unsigned long, DaiInfo*>::iterator iter = m_pDaiFile->setDaiInfo.begin();
		while(iter != m_pDaiFile->setDaiInfo.end())
		{
			DaiInfo* pDaiInfo = iter->second;
			if(pDaiInfo)
			{
				if(pDaiInfo->pFrameInfo)
					delete[] pDaiInfo->pFrameInfo;
				delete pDaiInfo;
				pDaiInfo = NULL;
			}
			iter ++;
		}
		m_pDaiFile->setDaiInfo.clear();
		
		int nDirAmount = m_pDaiFile->setDir.size();
		int i;
		for(i= 0; i < nDirAmount; i ++)
		{
			char* pszStr = m_pDaiFile->setDir[i];
			if(pszStr)
				delete[] pszStr;
		}
		m_pDaiFile->setDir.clear();			
		
		int nExtAmount = m_pDaiFile->setExt.size();
		for(i= 0; i < nExtAmount; i ++)
		{
			char* pszStr = m_pDaiFile->setExt[i];
			if(pszStr)
				delete[] pszStr;
		}
		m_pDaiFile->setExt.clear();			
	
		int nStrAmount = m_pDaiFile->setStr.size();
		for(i= 0; i < nStrAmount; i ++)
		{
			char* pszStr = m_pDaiFile->setStr[i];
			if(pszStr)
				delete[] pszStr;
		}
		m_pDaiFile->setStr.clear();			
	
		delete m_pDaiFile;
		m_pDaiFile = NULL;
	}

	if(m_pAniFileByOrder)
	{
		int nAmount = m_pAniFileByOrder->setAniInfo.size();
		for(int j = 0; j < nAmount; j ++)
		{
			AniInfoByOrder* pInfo = m_pAniFileByOrder->setAniInfo[j];
			if(pInfo)
			{
				int nStrAmounat = pInfo->setFrame.size();
				for(int i = 0; i < nStrAmounat; i++)
				{
					char* pStr = pInfo->setFrame[i];
					if(pStr)
						delete[] pStr;
				}
				pInfo->setFrame.clear();
				if(pInfo->pszIndex)
					delete[] pInfo->pszIndex;
				delete(pInfo);
				pInfo = NULL;
			}			
		}
		m_pAniFileByOrder->setAniInfo.clear();
		delete m_pAniFileByOrder;
		m_pAniFileByOrder = NULL;
	}

	if(m_pDaiFileByOrder)
	{
		int nAmount = m_pDaiFileByOrder->setDaiInfo.size();
		for(int j = 0; j < nAmount; j ++)
		{
			DaiInfo* pDaiInfo = m_pDaiFileByOrder->setDaiInfo[j];
			if(pDaiInfo)
			{
				if(pDaiInfo->pFrameInfo)
					delete[] pDaiInfo->pFrameInfo;
				delete pDaiInfo;
				pDaiInfo = NULL;
			}
		}
		m_pDaiFileByOrder->setDaiInfo.clear();	

		int nDirAmount = m_pDaiFileByOrder->setDir.size();
		int i;
		for(i= 0; i < nDirAmount; i ++)
		{
			char* pszStr = m_pDaiFileByOrder->setDir[i];
			if(pszStr)
				delete[] pszStr;
		}
		m_pDaiFileByOrder->setDir.clear();			
		
		int nExtAmount = m_pDaiFileByOrder->setExt.size();
		for(i= 0; i < nExtAmount; i ++)
		{
			char* pszStr = m_pDaiFileByOrder->setExt[i];
			if(pszStr)
				delete[] pszStr;
		}
		m_pDaiFileByOrder->setExt.clear();			
		
		int nStrAmount = m_pDaiFileByOrder->setStr.size();
		for(i= 0; i < nStrAmount; i ++)
		{
			char* pszStr = m_pDaiFileByOrder->setStr[i];
			if(pszStr)
				delete[] pszStr;
		}
		m_pDaiFileByOrder->setStr.clear();	
		
		delete m_pDaiFileByOrder;
		m_pDaiFileByOrder = NULL;
	}
}
//--------------------------------------------------------------------------------------
unsigned long	CAniFile::Load(const char* pszFile)
{
	if(!pszFile)
		return IDai::CODE_EXTERIOR_ERROR;
	// assay file name ... 
	char szDir[_MAX_DIR]		=	"";
	char szDrive[_MAX_PATH]		=	"";
	char szFileName[_MAX_FNAME]	=	"";
	char szExt[_MAX_EXT]			=	"";
	_splitpath(pszFile, szDrive, szDir, szFileName, szExt);
	strcpy(m_infoIndex.szFile, szFileName);
	strupr(m_infoIndex.szFile);
	strcpy(m_infoIndex.szPath, szDir);
	strupr(m_infoIndex.szPath);

	strupr(szExt);
	if(strcmp(szExt, ".DAI") == 0)
		return this->LoadDai(pszFile);
	else if(strcmp(szExt, ".ANI") == 0)
		return this->LoadAni(pszFile);
	return IDai::CODE_UNKNOW_FEXT;
}
//--------------------------------------------------------------------------------------
unsigned long	CAniFile::LoadAni(const char* pszFile)
{
	this->Clear();
	if(!pszFile)
		return IDai::CODE_EXTERIOR_ERROR;
	FILE* fp = fopen(pszFile, "r");
	if(!fp)
		return IDai::CODE_OPENFILE_FALSE;
	// create buffer to hold ani info
	m_pAniFile = new AniFileInfo;
	if(!m_pAniFile)
		return IDai::CODE_INTERIOR_ERROR;

	int nLineCounter = 0;
	while(true)
	{
		// scan title
		char szLine[1024] = "";
		if(EOF == fscanf(fp, "%s\n", szLine))
		{
			fclose(fp);
			return IDai::SUCCESS;
		}
		// inc the line counter ...
		nLineCounter ++;

		// check whether current line is title, if title assay else skip ...
		static char szTitle[MAX_PATH] = "";
		if (1 != sscanf(szLine, "[%s", szTitle))
			continue;
		char* p =strchr(szTitle, ']');
		if (p)
		{
			*p = '\0';
		}
		else
		{
			fclose(fp);
			this->Clear();
			m_uLastErrorLine = nLineCounter;
			return IDai::CODE_TITLEFORMAT_ERROE;
		}
		
		// get frame amount now
		int nFrameAmount = 0;
		if (1 != fscanf(fp, "FrameAmount=%d\n", &nFrameAmount))
		{
			fclose(fp);
			this->Clear();
			m_uLastErrorLine = nLineCounter;
			return IDai::CODE_FRAMEAMOUNT_ERROR;
		}
		if(nFrameAmount > MAX_ANIFRAMEAMOUNT && nFrameAmount < 0)
		{
			fclose(fp);
			this->Clear();
			m_uLastErrorLine = nLineCounter;
			return IDai::CODE_FRAMEAMOUNT_OVERFLOW;
		} 
		// create new ani buffer to hold the frames ...
		AniInfo* pFrameInfo = new AniInfo;
		if(!pFrameInfo)
		{
			fclose(fp);
			this->Clear();
			m_uLastErrorLine = nLineCounter;
			return IDai::CODE_INTERIOR_ERROR;
		} 
		unsigned long idIndex = this->Str2Id(szTitle);
		m_pAniFile->setAniInfo[idIndex] = pFrameInfo;

		// get frame now
		for(int i = 0; i < nFrameAmount; i ++)
		{
			static char szFormat[MAX_PATH] = "";
			sprintf(szFormat, "Frame%d=%s\n", i, "%s");
			
			char szFile[MAX_PATH] = "";
			if (1 != fscanf(fp, szFormat, szFile))
			{
				fclose(fp);
				this->Clear();
				m_uLastErrorLine = nLineCounter;
				return IDai::CODE_FRAMEINFO_ERROR;
			}
			char* pszFile = new char[strlen(szFile)+1];
			if(!pszFile)
			{
				fclose(fp);
				this->Clear();
				m_uLastErrorLine = nLineCounter;
				return IDai::CODE_INTERIOR_ERROR;
			} 			
			strcpy(pszFile, szFile);
			pFrameInfo->setFrame.push_back(pszFile);
		}
		
	}

	fclose(fp);
	return IDai::SUCCESS;
}
//--------------------------------------------------------------------------------------
unsigned long	CAniFile::LoadDai(const char* pszFile)
{
	this->Clear();
	if(!pszFile)
		return IDai::CODE_EXTERIOR_ERROR;
	FILE* fp = fopen(pszFile, "rb");
	if(!fp)
		return IDai::CODE_OPENFILE_FALSE;

	m_pDaiFile = new DaiFileInfo;
	if(!m_pDaiFile)
		return IDai::CODE_INTERIOR_ERROR;

	char szTitle[8];
	DWORD dwVersion;
	fread(szTitle, sizeof(char), 8, fp);
	if(strcmp(szTitle, "ND_DAI") != 0)
		return IDai::CODE_UNKNOW_FILEHEAD;
	fread(&dwVersion, sizeof(DWORD), 1, fp);
	if(dwVersion != 1000)
		return IDai::CODE_UNKNOW_VERSION;

	// read path ...
	int i;
	unsigned short usPathAmount;
	fread(&usPathAmount, sizeof(unsigned short), 1, fp);
	for(i = 0; i < usPathAmount; i ++)
	{
		
		unsigned short usLength;
		fread(&usLength, sizeof(unsigned short), 1, fp);
		char* pszStr = new char[usLength];
		if(!pszStr)
		{
			fclose(fp);
			this->Clear();
			return IDai::CODE_INTERIOR_ERROR;
		}
		fread(pszStr, sizeof(char), usLength, fp);
		m_pDaiFile->setDir.push_back(pszStr);
	}
	
	// read Ext ...
	unsigned char ucExtAmount;
	fread(&ucExtAmount, sizeof(unsigned char), 1, fp);
	for(i = 0; i < ucExtAmount; i ++)
	{
		unsigned short usLength;
		fread(&usLength, sizeof(unsigned short), 1, fp);
		char* pszStr = new char[usLength];
		if(!pszStr)
		{
			fclose(fp);
			this->Clear();
			return IDai::CODE_INTERIOR_ERROR;
		}
		fread(pszStr, sizeof(char), usLength, fp);
		m_pDaiFile->setExt.push_back(pszStr);
	}
	
	// read Str ...
	unsigned short usStrAmount;
	fread(&usStrAmount, sizeof(unsigned short), 1, fp);
	for(i = 0; i < usStrAmount; i ++)
	{
		unsigned short usLength;
		fread(&usLength, sizeof(unsigned short), 1, fp);

		char* pszStr = new char[usLength];
		if(!pszStr)
		{
			fclose(fp);
			this->Clear();
			return IDai::CODE_INTERIOR_ERROR;
		}
		fread(pszStr, sizeof(char), usLength, fp);
		m_pDaiFile->setStr.push_back(pszStr);
	}
	
	// read Ani Amount ...