Exemplo n.º 1
0
void CPremiumPlayerCtrl::
LoadIniFile(const char* szpIniFileName,struct i3client_t::tagPremiumInfo* pPremium)
{


	char AppName[_MAX_PATH];
	char inStr[_MAX_PATH];
	char Session[_MAX_PATH];	

	
	

	
	
	for(int idx=0; idx < i3client_t::tagPremiumInfo::maxmap_number; idx++){

		wsprintf(AppName,"Map%02d",idx);

		
		::GetPrivateProfileString(AppName,"Allow","YES",inStr,_MAX_PATH,szpIniFileName);
		pPremium->Map[idx].Default.bAllow = GetBOOL(inStr);

		
		::GetPrivateProfileString(AppName,"iRemainSecond","2147483647",inStr,_MAX_PATH,szpIniFileName);
		pPremium->Map[idx].Default.iRemainSecond=GetINT(inStr);

		
		::GetPrivateProfileString(AppName,"bDecreseRemainSecond","NO",inStr,_MAX_PATH,szpIniFileName);
		pPremium->Map[idx].Default.bDecreseRemainSecond=GetBOOL(inStr);

		
		::GetPrivateProfileString(AppName,"bDecreseAllRemainSecond","NO",inStr,_MAX_PATH,szpIniFileName);
		pPremium->Map[idx].Default.bDecreseAllRemainSecond = GetBOOL(inStr);

		
		::GetPrivateProfileString(AppName,"fAddExpRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
		pPremium->Map[idx].Default.fAddExpRatio = GetFLOAT(inStr);

		
		::GetPrivateProfileString(AppName,"fAddGenExpRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
		pPremium->Map[idx].Default.fAddGenExpRatio = GetFLOAT(inStr);

		
		::GetPrivateProfileString(AppName,"fAddGenCapabilityRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
		pPremium->Map[idx].Default.fAddGenCapabilityRatio=GetFLOAT(inStr);

		
		::GetPrivateProfileString(AppName,"fAddItemDropRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
		pPremium->Map[idx].Default.fAddItemDropRatio =GetFLOAT(inStr);

		
		::GetPrivateProfileString(AppName,"fAddNarkRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
		pPremium->Map[idx].Default.fAddNarkRatio = GetFLOAT(inStr);
		

		pPremium->Map[idx].Cur = pPremium->Map[idx].Default;
	}




	
	wsprintf(AppName,"Gameble");
	
	::GetPrivateProfileString(AppName,"fAddPriceRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
	pPremium->Gamble.fAddPriceRatio = GetFLOAT(inStr);

	for(idx=0; idx < i3client_t::tagPremiumInfo::tagGamble::maxnum_apperance_item_group; idx++){
		wsprintf(Session,"Group%02d");
		
		::GetPrivateProfileString(AppName,Session,"YES",inStr,_MAX_PATH,szpIniFileName);
		pPremium->Gamble.ItemGroupArray[idx].bApperance=GetBOOL(inStr);
	}



	wsprintf(AppName,"ItemOptionUpgrade");
	
	
	::GetPrivateProfileString(AppName,"iMaxlevel","10",inStr,_MAX_PATH,szpIniFileName);
	pPremium->ItemOptionUpgrade.iMaxlevel = GetINT(inStr);


	
	::GetPrivateProfileString(AppName,"fAddPriceRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
	pPremium->ItemOptionUpgrade.fAddPriceRatio = GetFLOAT(inStr);	

	
	
	wsprintf(AppName,"Die");
	
	::GetPrivateProfileString(AppName,"fExpRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
	pPremium->Die.fExpRatio = GetFLOAT(inStr);
	
	
	::GetPrivateProfileString(AppName,"fNakRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
	pPremium->Die.fNakRatio = GetFLOAT(inStr);
	



	
	
	::GetPrivateProfileString("PremiumBooth","Use","FALSE",inStr,_MAX_PATH,szpIniFileName);
	pPremium->bCreatePremiumBooth = GetBOOL(inStr);
	


	
	
	::GetPrivateProfileString("ItemCraft","iMaxLevel","10",inStr,_MAX_PATH,szpIniFileName);
	pPremium->iMaxLevelItemCraft = GetINT(inStr);
	


	
	
	::GetPrivateProfileString("ItemPrecocity","TimeRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
	pPremium->fItemPrecocityTimeRatio = GetFLOAT(inStr);
	


	
	
	::GetPrivateProfileString("ItemRecycle","Use","YES",inStr,_MAX_PATH,szpIniFileName);
	pPremium->bItemRecycle = GetBOOL(inStr);

	
	pPremium->GonyounPracticeBattle.lDate = time(NULL);
	
	::GetPrivateProfileString("GonyounPracticeBattle","iMaxCount","5",inStr,_MAX_PATH,szpIniFileName);
	pPremium->GonyounPracticeBattle.iMaxCount = GetINT(inStr);	
	pPremium->GonyounPracticeBattle.iDecreseCount = pPremium->GonyounPracticeBattle.iMaxCount;



	
	pPremium->WorldChatting.lDate = time(NULL);
	
	::GetPrivateProfileString("WorldChatting","iMaxCount","10",inStr,_MAX_PATH,szpIniFileName);
	pPremium->WorldChatting.iMaxCount = GetINT(inStr);	
	pPremium->WorldChatting.iDecreaseCount = pPremium->WorldChatting.iMaxCount;




	
	
	::GetPrivateProfileString("Status","iDefaultInitCount","1",inStr,_MAX_PATH,szpIniFileName);
	pPremium->Status.iDefaultInitCount= GetINT(inStr);
	
	
	::GetPrivateProfileString("Status","iInitCount","1000",inStr,_MAX_PATH,szpIniFileName);
	pPremium->Status.iInitCount=GetINT(inStr);

}
Exemplo n.º 2
0
void NscScriptDecompile (CNwnStream &sStream, 
	unsigned char *pauchData, unsigned long ulSize)
{

	//
	// Loop through the data
	//

	unsigned char *pStart = pauchData;
	unsigned char *pEnd = &pauchData [ulSize];
	unsigned char *pData = pStart;
	pData += 8;
	while (pData < pEnd)
	{
		char szByteText [128];
		char szOpText [512];
		char szOpType [32];
		char *pszOpRoot;

		//
		// Switch based on the next opcode
		//

		unsigned char *pOp = pData;
		unsigned char cOp = *pData++;
		switch (cOp)
		{

			case NscCode_CPDOWNSP:
				{
					if (&pData [7] > pEnd || pData [0] != 1)
						goto invalid_op;
					unsigned long ul1, ul2;
					pData = GetUINT32 (pData + 1, &ul1);
					pData = GetUINT16 (pData, &ul2);
					sprintf (szByteText, "%02X 01 %08X %04X", cOp, ul1, ul2);
					sprintf (szOpText, "CPDOWNSP %08X, %04X", ul1, ul2);
				}
				break;

			case NscCode_RSADD:
				pszOpRoot = "RSADD";
do_simple_operator:;
				{
					if (&pData [1] > pEnd)
						goto invalid_op;
					unsigned char cOpType = *pData++;
					GetOpText (cOpType, szOpType);
					sprintf (szByteText, "%02X %02X", cOp, cOpType);
					sprintf (szOpText, "%s%s", pszOpRoot, szOpType);
				}
				break;

			case NscCode_CPTOPSP:
				{
					if (&pData [7] > pEnd || pData [0] != 1)
						goto invalid_op;
					unsigned long ul1, ul2;
					pData = GetUINT32 (pData + 1, &ul1);
					pData = GetUINT16 (pData, &ul2);
					sprintf (szByteText, "%02X 01 %08X %04X", cOp, ul1, ul2);
					sprintf (szOpText, "CPTOPSP %08X, %04X", ul1, ul2);
				}
				break;

			case NscCode_WRAR:
				{
					if (&pData [7] > pEnd || pData [0] != 1)
						goto invalid_op;
					unsigned long ul1, ul2;
					pData = GetUINT32 (pData + 1, &ul1);
					pData = GetUINT16 (pData, &ul2);
					sprintf (szByteText, "%02X 01 %08X %04X", cOp, ul1, ul2);
					sprintf (szOpText, "WRAR %08X, %04X", ul1, ul2);
				}
				break;

			case NscCode_RDAR:
				{
					if (&pData [7] > pEnd || pData [0] != 1)
						goto invalid_op;
					unsigned long ul1, ul2;
					pData = GetUINT32 (pData + 1, &ul1);
					pData = GetUINT16 (pData, &ul2);
					sprintf (szByteText, "%02X 01 %08X %04X", cOp, ul1, ul2);
					sprintf (szOpText, "RDAR %08X, %04X", ul1, ul2);
				}
				break;

			case NscCode_GETREF:
				{
					if (&pData [7] > pEnd || pData [0] != 1)
						goto invalid_op;
					unsigned long ul1, ul2;
					pData = GetUINT32 (pData + 1, &ul1);
					pData = GetUINT16 (pData, &ul2);
					sprintf (szByteText, "%02X 01 %08X %04X", cOp, ul1, ul2);
					sprintf (szOpText, "GETREF %08X, %04X", ul1, ul2);
				}
				break;

			case NscCode_GETREFA:
				{
					if (&pData [7] > pEnd || pData [0] != 1)
						goto invalid_op;
					unsigned long ul1, ul2;
					pData = GetUINT32 (pData + 1, &ul1);
					pData = GetUINT16 (pData, &ul2);
					sprintf (szByteText, "%02X 01 %08X %04X", cOp, ul1, ul2);
					sprintf (szOpText, "GETREFA %08X, %04X", ul1, ul2);
				}
				break;

			case NscCode_CONST:
				{
					if (&pData [1] > pEnd)
						goto invalid_op;
					unsigned char cOpType = *pData;
					GetOpText (cOpType, szOpType);
					switch (cOpType)
					{
						case 3:
						case 6:
							{
								if (&pData [5] > pEnd)
									goto invalid_op;
								unsigned long ul;
								pData = GetUINT32 (pData + 1, &ul);
								sprintf (szByteText, "%02X %02X %08X", cOp, cOpType, ul);
								sprintf (szOpText, "CONST%s %08X", szOpType, ul);
							}
							break;

						case 4:
							{
								if (&pData [5] > pEnd)
									goto invalid_op;
								union
								{
									unsigned long ul;
									float f;
								} val;
								pData = GetFLOAT (pData + 1, &val .f);
								sprintf (szByteText, "%02X %02X %08X", cOp, cOpType, val .ul);
								sprintf (szOpText, "CONST%s %f", szOpType, val .f);
							}
							break;

						case 5:
						case 96:
							{
								if (&pData [3] > pEnd)
									goto invalid_op;
								unsigned long ul;
								GetUINT16 (pData + 1, &ul);
								if (&pData [3 + ul] > pEnd)
									goto invalid_op;
								pData += 3;
								char szValue [129];
								unsigned long ulCopy = ul > 128 ? 128 : ul;
								memmove (szValue, pData, ulCopy);
								szValue [ulCopy] = 0;
								sprintf (szByteText, "%02X %02X %04X str", cOp, cOpType, ul);
								snprintf (szOpText, _countof (szOpText), 
									"CONST%s \"%s\"", szOpType, szValue);
								pData += ul;
							}
							break;

						default:
							goto invalid_op;
					}
				}
				break;

			case NscCode_ACTION:
				{
					if (&pData [4] > pEnd || pData [0] != 0)
						goto invalid_op;
					unsigned long ul1, ul2;
					pData = GetUINT16 (pData + 1, &ul1);
					ul2 = *pData++;
					const char *pszName = NscGetActionName ((int) ul1);
					sprintf (szByteText, "%02X 00 %04X %02X", cOp, ul1, ul2);
					sprintf (szOpText, "ACTION %s(%04X), %02X", pszName, ul1, ul2);
				}
				break;

			case NscCode_LOGAND:
				pszOpRoot = "LOGAND";
do_binary_operator:;
				{
					if (&pData [1] > pEnd)
						goto invalid_op;
					unsigned char cOpType = *pData++;
					GetOpText (cOpType, szOpType);
					if (cOpType == 0x24)
					{
						if (&pData [2] > pEnd)
							goto invalid_op;
						unsigned long ul1;
						pData = GetUINT16 (pData, &ul1);
						sprintf (szByteText, "%02X %02X %04X", cOp, cOpType, ul1);
						sprintf (szOpText, "%s%s %04X", pszOpRoot, szOpType, ul1);
					}
					else
					{
						sprintf (szByteText, "%02X %02X", cOp, cOpType);
						sprintf (szOpText, "%s%s", pszOpRoot, szOpType);
					}
				}
				break;

			case NscCode_LOGOR:
				pszOpRoot = "LOGOR";
				goto do_binary_operator;

			case NscCode_INCOR:
				pszOpRoot = "INCOR";
				goto do_binary_operator;

			case NscCode_EXCOR:
				pszOpRoot = "EXCOR";
				goto do_binary_operator;

			case NscCode_BOOLAND:
				pszOpRoot = "BOOLAND";
				goto do_binary_operator;

			case NscCode_EQUAL:
				pszOpRoot = "EQUAL";
				goto do_binary_operator;

			case NscCode_NEQUAL:
				pszOpRoot = "NEQUAL";
				goto do_binary_operator;

			case NscCode_GEQ:
				pszOpRoot = "GEQ";
				goto do_binary_operator;

			case NscCode_GT:
				pszOpRoot = "GT";
				goto do_binary_operator;

			case NscCode_LT:
				pszOpRoot = "LT";
				goto do_binary_operator;

			case NscCode_LEQ:
				pszOpRoot = "LEQ";
				goto do_binary_operator;

			case NscCode_SHLEFT:
				pszOpRoot = "SHLEFT";
				goto do_binary_operator;

			case NscCode_SHRIGHT:
				pszOpRoot = "SHRIGHT";
				goto do_binary_operator;

			case NscCode_USHRIGHT:
				pszOpRoot = "USHRIGHT";
				goto do_binary_operator;

			case NscCode_ADD:
				pszOpRoot = "ADD";
				goto do_binary_operator;

			case NscCode_SUB:
				pszOpRoot = "SUB";
				goto do_binary_operator;

			case NscCode_MUL:
				pszOpRoot = "MUL";
				goto do_binary_operator;

			case NscCode_DIV:
				pszOpRoot = "DIV";
				goto do_binary_operator;

			case NscCode_MOD:
				pszOpRoot = "MOD";
				goto do_binary_operator;

			case NscCode_NEG:
				pszOpRoot = "NEG";
				goto do_simple_operator;

			case NscCode_COMP:
				pszOpRoot = "COMP";
				goto do_simple_operator;

			case NscCode_MOVSP:
				{
					if (&pData [5] > pEnd || pData [0] != 0)
						goto invalid_op;
					unsigned long ul1;
					pData = GetUINT32 (pData + 1, &ul1);
					sprintf (szByteText, "%02X 00 %08X", cOp, ul1);
					sprintf (szOpText, "MOVSP %08X", ul1);
				}
				break;

			case NscCode_STORE_STATEALL:
				{
					if (&pData [1] > pEnd)
						goto invalid_op;
					unsigned long ul = *pData++;
					sprintf (szByteText, "%02X %02X", cOp, ul);
					sprintf (szOpText, "SAVE_STATEALL %02x", ul);
				}
				break;

			case NscCode_JMP:
				{
					if (&pData [5] > pEnd || pData [0] != 0)
						goto invalid_op;
					unsigned long ul1;
					pData = GetUINT32 (pData + 1, &ul1);
					sprintf (szByteText, "%02X 00 %08X", cOp, ul1);
					sprintf (szOpText, "JMP off_%08X", (pOp - pStart) + ul1);
				}
				break;

			case NscCode_JSR:
				{
					if (&pData [5] > pEnd || pData [0] != 0)
						goto invalid_op;
					unsigned long ul1;
					pData = GetUINT32 (pData + 1, &ul1);
					sprintf (szByteText, "%02X 00 %08X", cOp, ul1);
					sprintf (szOpText, "JSR fn_%08X", (pOp - pStart) + ul1);
				}
				break;

			case NscCode_JZ:
				{
					if (&pData [5] > pEnd || pData [0] != 0)
						goto invalid_op;
					unsigned long ul1;
					pData = GetUINT32 (pData + 1, &ul1);
					sprintf (szByteText, "%02X 00 %08X", cOp, ul1);
					sprintf (szOpText, "JZ off_%08X", (pOp - pStart) + ul1);
				}
				break;

			case NscCode_RETN:
				{
					if (&pData [1] > pEnd || pData [0] != 0)
						goto invalid_op;
					pData++;
					sprintf (szByteText, "%02X 00", cOp);
					sprintf (szOpText, "RETN");
				}
				break;

			case NscCode_DESTRUCT:
				{
					if (&pData [7] > pEnd || pData [0] != 1)
						goto invalid_op;
					unsigned long ul1, ul2, ul3;
					pData = GetUINT16 (pData + 1, &ul1);
					pData = GetUINT16 (pData, &ul2);
					pData = GetUINT16 (pData, &ul3);
					sprintf (szByteText, "%02X 01 %04X %04X %04x", cOp, ul1, ul2, ul3);
					sprintf (szOpText, "DESTRUCT %04X, %04X, %04X", ul1, ul2, ul3);
					// First parameter, number of bytes to destroy
					// Second parameter, offset of element not to destroy
					// Third parameter, number of bytes no to destroy
				}
				break;

			case NscCode_NOT:
				pszOpRoot = "NOT";
				goto do_simple_operator;

			case NscCode_DECISP:
				{
					if (&pData [5] > pEnd || pData [0] != 3)
						goto invalid_op;
					unsigned long ul1;
					pData = GetUINT32 (pData + 1, &ul1);
					sprintf (szByteText, "%02X 03 %08X", cOp, ul1);
					sprintf (szOpText, "DECISP %08X", ul1);
				}
				break;

			case NscCode_INCISP:
				{
					if (&pData [5] > pEnd || pData [0] != 3)
						goto invalid_op;
					unsigned long ul1;
					pData = GetUINT32 (pData + 1, &ul1);
					sprintf (szByteText, "%02X 03 %08X", cOp, ul1);
					sprintf (szOpText, "INCISP %08X", ul1);
				}
				break;

			case NscCode_JNZ:
				{
					if (&pData [5] > pEnd || pData [0] != 0)
						goto invalid_op;
					unsigned long ul1;
					pData = GetUINT32 (pData + 1, &ul1);
					sprintf (szByteText, "%02X 00 %08X", cOp, ul1);
					sprintf (szOpText, "JNZ off_%08X", (pOp - pStart) + ul1);
				}
				break;

			case NscCode_CPDOWNBP:
				{
					if (&pData [7] > pEnd || pData [0] != 1)
						goto invalid_op;
					unsigned long ul1, ul2;
					pData = GetUINT32 (pData + 1, &ul1);
					pData = GetUINT16 (pData, &ul2);
					sprintf (szByteText, "%02X 01 %08X %04X", cOp, ul1, ul2);
					sprintf (szOpText, "CPDOWNBP %08X, %04X", ul1, ul2);
				}
				break;

			case NscCode_CPTOPBP:
				{
					if (&pData [7] > pEnd || pData [0] != 1)
						goto invalid_op;
					unsigned long ul1, ul2;
					pData = GetUINT32 (pData + 1, &ul1);
					pData = GetUINT16 (pData, &ul2);
					sprintf (szByteText, "%02X 01 %08X %04X", cOp, ul1, ul2);
					sprintf (szOpText, "CPTOPBP %08X, %04X", ul1, ul2);
				}
				break;

			case NscCode_DECIBP:
				{
					if (&pData [5] > pEnd || pData [0] != 3)
						goto invalid_op;
					unsigned long ul1;
					pData = GetUINT32 (pData + 1, &ul1);
					sprintf (szByteText, "%02X 03 %08X", cOp, ul1);
					sprintf (szOpText, "DECIBP %08X", ul1);
				}
				break;

			case NscCode_INCIBP:
				{
					if (&pData [5] > pEnd || pData [0] != 3)
						goto invalid_op;
					unsigned long ul1;
					pData = GetUINT32 (pData + 1, &ul1);
					sprintf (szByteText, "%02X 03 %08X", cOp, ul1);
					sprintf (szOpText, "INCIBP %08X", ul1);
				}
				break;

			case NscCode_SAVEBP:
				{
					if (&pData [1] > pEnd || pData [0] != 0)
						goto invalid_op;
					pData++;
					sprintf (szByteText, "%02X 00", cOp);
					sprintf (szOpText, "SAVEBP");
				}
				break;

			case NscCode_RESTOREBP:
				{
					if (&pData [1] > pEnd || pData [0] != 0)
						goto invalid_op;
					pData++;
					sprintf (szByteText, "%02X 00", cOp);
					sprintf (szOpText, "RESTOREBP");
				}
				break;

			case NscCode_STORE_STATE:
				{
					if (&pData [9] > pEnd)
						goto invalid_op;
					unsigned long ul1, ul2, ul3;
					ul3 = *pData++;
					pData = GetUINT32 (pData, &ul1);
					pData = GetUINT32 (pData, &ul2);
					sprintf (szByteText, "%02X %02X %08X %08X", cOp, ul3, ul1, ul2);
					sprintf (szOpText, "STORE_STATE %02X, %08X, %08X", ul3, ul1, ul2);
				    // First value is BP stack size to save
					// second value is SP stack size to save
				}
				break;

			case NscCode_NOP:
				{
					if (&pData [1] > pEnd || pData [0] != 0)
						goto invalid_op;
					pData++;
					sprintf (szByteText, "%02X 00", cOp);
					sprintf (szOpText, "NOP");
				}
				break;

			case NscCode_Size:
				{
					if (&pData [4] > pEnd)
						goto invalid_op;
					unsigned long ul;
					pData = GetUINT32 (pData, &ul);
					sprintf (szByteText, "%02X %08X", cOp, ul);
					sprintf (szOpText, "T %08X", ul);
				}
				break;

			default:
invalid_op:;
				sprintf (szByteText, "%02X", cOp);
				sprintf (szOpText, "??");
				//if (g_fpDebug)
				//	fprintf (g_fpDebug, "Unknown opcode %02x\r\n", cOp);
				break;
		}

		//
		// Format the final line
		//

		char szText [1024];
		sprintf (szText, "%08X %-24s %s", pOp - pStart, szByteText, szOpText);
		sStream .WriteLine (szText);
	}
}