datacovertdlg.cpp

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

		::IniDataGet(szIniFile,szTitle,szSubTitle,nData);
		pInfo->nMagicId = nData;

		strcpy(szSubTitle,"MagicLevel");
		::IniDataGet(szIniFile,szTitle,szSubTitle,nData);
		pInfo->nMagicLevel = nData;

		strcpy(szSubTitle, "HelpLineAmount");
		::IniDataGet(szIniFile, szTitle, szSubTitle, nData);
		dwStrAmount = nData;

		for(int j = 0; j < dwStrAmount; j ++)
		{
			sprintf(szSubTitle, "Line%d", j);
			::IniStrGet(szIniFile, szTitle, szSubTitle, szStr);
			str = szStr;
			pInfo->m_setStr.push_back(str);
		}
		m_setUserHelpInfo.push_back(pInfo);
	}
	
	// write ...
	const char szDataFile[] = "ini/UserHelpInfo.dat";
	FILE* fp = fopen(szDataFile, "wb");
	if(!fp)
		this->AddMsg("打开文件 ini/UserHelpInfo.dat 写错误");
	// header
	char szHeader[32]="UserHelpInfo";
	fwrite(szHeader, sizeof(char), 32, fp);
	// version
	DWORD dwVersion = 1000;
	fwrite(&dwVersion, sizeof(DWORD), 1, fp);
	// amount ...
	DWORD dwRecordAmount = m_setUserHelpInfo.size();
	fwrite(&dwRecordAmount, sizeof(DWORD), 1, fp);
	for(DWORD dwCounter = 0; dwCounter < dwRecordAmount; dwCounter++)
	{
		UserHelpInfo* pInfo = m_setUserHelpInfo[dwCounter];
		if(pInfo)
		{
			fwrite(&pInfo->nMaxLevel, sizeof(int), 1, fp);
			fwrite(&pInfo->nMinLevel, sizeof(int), 1, fp);
			fwrite(&pInfo->nProfession, sizeof(int), 1, fp);
			fwrite(&pInfo->nSex,sizeof(int),1,fp);
			fwrite(&pInfo->nMapId,sizeof(int),1,fp);
			fwrite(&pInfo->nStatus,sizeof(int),1,fp);
			fwrite(&pInfo->nStatusLevel,sizeof(int),1,fp);
			fwrite(&pInfo->nItemType,sizeof(int),1,fp);
			fwrite(&pInfo->nMagicId,sizeof(int),1,fp);
			fwrite(&pInfo->nMagicLevel,sizeof(int),1,fp);
			
			// record Help string ...
			DWORD dwStrAmount = pInfo->m_setStr.size();
			fwrite(&dwStrAmount, sizeof(DWORD), 1, fp);
			for(DWORD dwStrCounter = 0; dwStrCounter < dwStrAmount; dwStrCounter++)
			{
				// write length
				DWORD dwLength = pInfo->m_setStr[dwStrCounter].length()+1;
				fwrite(&dwLength, sizeof(DWORD), 1, fp);

				// write str
				fwrite(pInfo->m_setStr[dwStrCounter].c_str(), sizeof(char), dwLength, fp);
			}
		}
		SAFE_DELETE(pInfo);
	}
	m_setUserHelpInfo.clear();
	this->AddMsg("完成 ini/UserHelpInfo.dat");
	fclose(fp);
}

void CDataCovertDlg::OnMenuitemTipsC() 
{
	// TODO: Add your command handler code here
	this->AddMsg("Tips.ini>>>>Tips.dat");
	const char szIniFile[] = "ini/Tips.ini";
	char	szTitle[64];
	char	szSubTitle[64];
	char	szStr[512];
	int		nData;
	int		i;
	string	str;

	//Part1: header ...
	DWORD dwInfoAmount = 0;
	strcpy(szTitle, "Header");
	strcpy(szSubTitle, "Amount");
	::IniDataGet(szIniFile, szTitle, szSubTitle, nData);
	dwInfoAmount = nData;

	//Part2: text ...
	for(i = 0; i < dwInfoAmount; i ++)
	{
		TipInfo* pInfo = new TipInfo;
		MYASSERT(pInfo);
		//int nLineAmount;
		sprintf(szTitle, "Tip%d", i);
		sprintf(szSubTitle, "Amount");
		::IniDataGet(szIniFile, szTitle, szSubTitle, nData);
		for(int j = 0; j < nData; j ++)
		{
			sprintf(szSubTitle, "Line%d", j);
			::IniStrGet(szIniFile, szTitle, szSubTitle, szStr);
			pInfo->m_setStr.push_back(string(szStr));
		}
		m_setTipInfo.push_back(pInfo);
	}
	
	// write ...
	const char szDataFile[] = "ini/Tips.dat";
	FILE* fp = fopen(szDataFile, "wb");
	if(!fp)
		this->AddMsg("打开文件 ini/Tips.dat 写错误");
	// header
	char szHeader[32]="Tips";
	fwrite(szHeader, sizeof(char), 32, fp);
	// version
	DWORD dwVersion = 1000;
	fwrite(&dwVersion, sizeof(DWORD), 1, fp);
	// amount ...
	DWORD dwRecordAmount = m_setTipInfo.size();
	fwrite(&dwRecordAmount, sizeof(DWORD), 1, fp);

	for(DWORD dwCounter = 0; dwCounter < dwRecordAmount; dwCounter++)
	{
		TipInfo* pInfo = m_setTipInfo[dwCounter];
		if(pInfo)
		{
			// record string ...
			DWORD dwStrAmount = pInfo->m_setStr.size();
			fwrite(&dwStrAmount, sizeof(DWORD), 1, fp);
			for(DWORD dwStrCounter = 0; dwStrCounter < dwStrAmount; dwStrCounter++)
			{
				// write length
				DWORD dwLength = pInfo->m_setStr[dwStrCounter].length()+1;
				fwrite(&dwLength, sizeof(DWORD), 1, fp);

				// write str
				fwrite(pInfo->m_setStr[dwStrCounter].c_str(), sizeof(char), dwLength, fp);
			}
		}
		SAFE_DELETE(pInfo);
	}
	m_setTipInfo.clear();
	this->AddMsg("完成 ini/Tips.dat");
	fclose(fp);	
}

void CDataCovertDlg::OnMenuitemPetc() 
{
	// TODO: Add your command handler code here
	// ini/pet.ini
	this->AddMsg("Pet.ini>>>>Pet.dat");
	const char szIniFile[] = "ini/Pet.Ini";
	
	// load ini to buffer ...
	// buffer define ...

	vector<PetInfo> setPetInfo;
	
	// prepare...
	char szTitle[256];
	char szSubTitle[256];
	int i, j;
	// read header...
	int nAmount = 0;
	strcpy(szTitle, "Header");
	strcpy(szSubTitle, "Amount");
	if(!::IniDataGet(szIniFile, szTitle, szSubTitle, nAmount))
	{
		this->AddMsg("Header错误");
		return;
	}

	// read record...
	for(i = 0; i < nAmount; i ++)	
	{
		PetInfo infoPet;
		sprintf(szTitle, "Type%d", i);
		strcpy(szSubTitle, "LocateTargetMethodAmount");
		int nLocateTargetMethodAmount = 0;
		if(!::IniDataGet(szIniFile, szTitle, szSubTitle, nLocateTargetMethodAmount))
		{
			this->AddMsg("LocateTargetMethodAmount错误");
			return;
		}
		for(j = 0; j < nLocateTargetMethodAmount; j ++)
		{
			int nData;
			sprintf(szSubTitle, "LocateTargetMethod%d", j);
			if(!::IniDataGet(szIniFile, szTitle, szSubTitle, nData))
			{
				this->AddMsg("LocateTargetMethod错误");
				return;
			}
			infoPet.setLocateTargetMethod.push_back(nData);
		}
		int nData;
		strcpy(szSubTitle, "EnvMethod");
		if(!::IniDataGet(szIniFile, szTitle, szSubTitle, nData))
		{
			this->AddMsg("EnvMethod错误");
			return;
		}
		infoPet.nEnvMethod = nData;

		strcpy(szSubTitle, "Scale");
		if(!::IniDataGet(szIniFile, szTitle, szSubTitle, nData))
		{
			this->AddMsg("Scale错误");
			return;
		}
		infoPet.nScale = nData;

		strcpy(szSubTitle, "AttackRange");
		if(!::IniDataGet(szIniFile, szTitle, szSubTitle, nData))
		{
			this->AddMsg("AttackRange错误");
			return;
		}
		infoPet.nAttackRange = nData;

		strcpy(szSubTitle, "AttackInterval");
		if(!::IniDataGet(szIniFile, szTitle, szSubTitle, nData))
		{
			this->AddMsg("AttackInterval错误");
			return;
		}
		infoPet.dwAttackInterval = nData;

		strcpy(szSubTitle, "AddSize");
		if(!::IniDataGet(szIniFile, szTitle, szSubTitle, nData))
		{
			this->AddMsg("AddSize错误");
			return;
		}
		infoPet.nAddSize = nData;

		setPetInfo.push_back(infoPet);
		infoPet.setLocateTargetMethod.clear();
	}
	

	const char szDataFile[] = "ini/Pet.Dat";
	FILE* fData = fopen(szDataFile, "wb");
	if(!fData)
	{
		this->AddMsg("打开Pet.Dat错误");
		return;
	}

	// write amount ...
	nAmount = setPetInfo.size();
	fwrite(&nAmount, sizeof(int), 1, fData);
	for(i = 0; i < nAmount; i ++)
	{
		DWORD dwCheck = 0;
		int nData;
		PetInfo infoPet = setPetInfo[i];
		
		// write Method Amount ...
		DWORD dwSize = infoPet.setLocateTargetMethod.size();
		fwrite(&dwSize, sizeof(int), 1, fData);
		
		// write Method
		for(j = 0; j < infoPet.setLocateTargetMethod.size(); j++)
		{
			int nMethod = infoPet.setLocateTargetMethod[j];
			fwrite(&nMethod, sizeof(int), 1, fData);
			dwCheck += nMethod;
		}

		// others ...
		fwrite(&infoPet.nEnvMethod, sizeof(int), 1, fData);	
		fwrite(&infoPet.nAddSize, sizeof(int), 1, fData);	
		fwrite(&infoPet.nScale, sizeof(int), 1, fData);	
		fwrite(&infoPet.nAttackRange, sizeof(int), 1, fData);	
		fwrite(&infoPet.dwAttackInterval, sizeof(DWORD), 1, fData);	
		dwCheck = dwSize*dwCheck;
		dwCheck += infoPet.nEnvMethod + infoPet.setLocateTargetMethod.size() * 2 
						+ infoPet.nAddSize + infoPet.nAttackRange * infoPet.dwAttackInterval;
		fwrite(&dwCheck, sizeof(DWORD), 1, fData);	
	}
	fclose(fData);
	this->AddMsg("完成");
}

void CDataCovertDlg::OnMenuitemNamelistC() 
{
	// TODO: Add your command handler code here
	char szFile[]="ini/itemtype.ini";
	this->AddMsg("开始生成ItemNameList.ini数据！");
	FILE* fp = fopen(szFile, "r");
	char szMsg[1024];
	if(!fp)
	{
		sprintf(szMsg, "打开文件：%s出错，操作停止。请确认文件是否存在或被锁定！", szFile);
		this->AddMsg(szMsg);
		return;
	}

	// 取记录数量
	unsigned int uRecordAmount;
	int nReturn = fscanf(fp, "Amount=%u\n", &uRecordAmount);
	if(nReturn <= 0)
	{
		this->AddMsg("读取记录数量失败，操作停止！");
		fclose(fp);
		return;
	}
	ItemTypeInfo* pInfo = new ItemTypeInfo[uRecordAmount];
	if(!pInfo)
	{
		this->AddMsg("分配记录临时内存失败，操作停止！");
		fclose(fp);
		return;
	}

	// 加载记录
	DWORD i = 0;
	
	for(i = 0; i < uRecordAmount; i++)
	{
		int	nData[50] = {0};
		char	szName[16] = "";
		char	szDesc[128] = "";
		nReturn = fscanf(fp, "%u %s %u %u %u %u %u %u %u %u %u %u %u %u %u %d %d %d %d %d %d %u %u %u %u %u %u %u %u %u %u %u %u %d %u %s\n", 
			&nData[0],
			szName,
			&nData[1],
			&nData[2],
			&nData[3],
			&nData[4],
			&nData[5],
			&nData[6],
			&nData[7],
			&nData[8],
			&nData[9],
			&nData[10],
			&nData[11],
			&nData[12],
			&nData[13],
			&nData[14],
			&nData[15],
			&nData[16],
			&nData[17],
			&nData[18],
			&nData[19],
			&nData[20],
			&nData[21],
			&nData[22],
			&nData[23],
			&nData[24],
			&nData[25],
			&nData[26],
			&nData[27],
			&nData[28],
			&nData[29],
			&nData[30],
			&nData[31],
			&nData[32],
			&nData[33],
			szDesc
			);

		if (nReturn != 36)
		{
			sprintf(szMsg, "读取第%u条记录出错，操作停止！", i);
			this->AddMsg(szMsg);
			fclose(fp);
			delete[] pInfo;
			return;
		}
		
		ItemTypeInfo* pMyInfo = pInfo + i;
		pMyInfo->uID						=	(DWORD)nData[0];
		strcpy(pMyInfo->szName, szName);
		pMyInfo->ucRequiredProfession		=	(unsigned char)nData[1];
		pMyInfo->ucRequiredWeaponSkill		=	(unsigned char)nData[2];
		pMyInfo->ucRequiredLevel			=	(unsigned char)nData[3];
		pMyInfo->ucRequiredSex				=	(unsigned char)nData[4];
		pMyInfo->usRequiredForce			=	(unsigned short)nData[5];
		pMyInfo->usRequiredSpeed			=	(unsigned short)nData[6];
		pMyInfo->usRequiredHealth 			=	(unsigned short)nData[7];
		pMyInfo->usRequiredSoul 			=	(unsigned short)nData[8];
		pMyInfo->ucMonopoly					=	(unsigned char)nData[9];
		pMyInfo->usWeight					=	(unsigned short)nData[10];
		pMyInfo->uPrice						=	nData[11];
		pMyInfo->uLuck						=	nData[12];
		pMyInfo->usMaxAttack				=	(short)nData[13];
		pMyInfo->usMinAttack				=	(short)nData[14];
		pMyInfo->usDefense					=	(short)nData[15];
		pMyInfo->usDexterity				=	(short)nData[16];
		pMyInfo->usDodge					=	(short)nData[17];
		pMyInfo->sLife						=	(short)nData[18];
		pMyInfo->sMana						=	(short)nData[19];
		pMyInfo->usAmount					=	(unsigned short)nData[20];
		pMyInfo->usAmountLimit				=	(unsigned short)nData[21];
		pMyInfo->ucStatus					=	(unsigned char)nData[22];
		pMyInfo->ucGem1						=	(unsigned char)nData[23];
		pMyInfo->ucGem2						=	(unsigned char)nData[24];
		pMyInfo->ucMagic1					=	(unsigned char)nData[25];
		pMyInfo->ucMagic2					=	(unsigned char)nData[26];
		pMyInfo->ucMagic3					=	(unsigned char)nData[27];
		pMyInfo->usMagicAttack				=	(unsigned short)nData[28];
		pMyInfo->usMagicDefence				=	(unsigned short)nData[29];
		pMyInfo->usRange					=	(unsigned short)nData[30];
		pMyInfo->usAttackSpeed				=	(unsigned short)nData[31];
		pMyInfo->usHitarte					=	nData[32];
		pMyInfo->usTarget					=   (unsigned short)nData[33];
		strcpy(pMyInfo->szDesc, szDesc);
	}	
	fclose(fp);
	
	// 打开目标文件
	char szDFile[]="ini/itemnamelist.ini";
	fp = fopen(szDFile, "wb");
	if(!fp)
	{
		sprintf(szMsg, "打开文件：%s出错，操作停止。请确认文件是否被锁定！", szDFile);
		this->AddMsg(szMsg);
		delete[] pInfo;
		return;
	}

	// 写索引
	int nSaveAmount = 0;
	for(i = 0; i < uRecordAmount; i++)
	{

		ItemTypeInfo* pMyInfo = pInfo + i;
		BOOL bNoName = true;
		for(int j = 0;j < i;j++)
		{
			ItemTypeInfo* pCheckInfo = pInfo + j;
			if (pInfo && strcmp(pCheckInfo->szName,pMyInfo->szName) == 0) 
			{
				bNoName = false;
				break;
			}
		}
		if ( !bNoName ) 
			continue;		
		fprintf(fp,"%s\n", pMyInfo->szName);
		nSaveAmount++;
	}

	sprintf(szMsg, "ItemNameList.ini数据生成成功，文件写入%s，共有%u个记录。", szDFile, nSaveAmount);
	this->AddMsg(szMsg);
	fclose(fp);
	delete[] pInfo;
}