509 lines
No EOL
14 KiB
C++
509 lines
No EOL
14 KiB
C++
|
|
#include "stdafx.h"
|
|
#include <stdio.h>
|
|
|
|
#include <vector>
|
|
#include <map>
|
|
|
|
#include <algorithm>
|
|
|
|
#define PRE_ADD_COMPARE_TABLE // bintitle.
|
|
|
|
#include "DNTableFile.h"
|
|
#include "MemPool.h"
|
|
#include "DnItemCompounder.h"
|
|
#include "SundriesFunc.h"
|
|
|
|
|
|
using namespace std;
|
|
|
|
|
|
struct SCell
|
|
{
|
|
int mainID; // 메인테이블에서의 ID.
|
|
int enchantID;
|
|
int enchatLevel;
|
|
|
|
int id; // ItemID.
|
|
string name; // 컬럼명.
|
|
DNTableCell * pData; // 데이타.
|
|
};
|
|
|
|
//typedef vector< vector< SCell > * > vNT;
|
|
//vNT g_newTable;
|
|
typedef std::map< int, vector< SCell > * > vNT;
|
|
vNT g_newTable;
|
|
|
|
|
|
enum E_TABLE
|
|
{
|
|
ENCHANTTABLE = 0,
|
|
ENCHANTMAINTABLE = 1,
|
|
ENCHANTMAXSTATETABLE = 2,
|
|
ENCHANTNEEDITEMTABLE = 3,
|
|
|
|
MAX
|
|
};
|
|
|
|
int GetFiledNameIndex( vector< string > & vVector, const char * name )
|
|
{
|
|
int resIndex = -1;
|
|
int size = vVector.size();
|
|
for( int i=0; i<size; ++i )
|
|
{
|
|
if( vVector[i].compare( name ) == 0 )
|
|
{
|
|
resIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
return resIndex;
|
|
}
|
|
|
|
void main()
|
|
{
|
|
//// .ext 파일들.
|
|
//std::vector< std::string > vFileNames;
|
|
//vFileNames.push_back("enchanttable");
|
|
//vFileNames.push_back("enchantmaintable");
|
|
//vFileNames.push_back("enchantmaxstatetable");
|
|
//vFileNames.push_back("enchantneeditemtable");
|
|
|
|
//// Tables.
|
|
//std::vector< DNTableFileFormat * > vTables;
|
|
//DNTableFileFormat * pTable = NULL;
|
|
|
|
//// 테이블 생성.
|
|
//for( int i=E_TABLE::ENCHANTTABLE; i<E_TABLE::MAX; ++i )
|
|
//{
|
|
// pTable = new DNTableFileFormat;
|
|
// pTable->Load( ( vFileNames[ i ] + ".ext" ).c_str() );
|
|
// pTable->SetLoadName( vFileNames[ i ].c_str() );
|
|
// vTables.push_back( pTable );
|
|
//}
|
|
|
|
|
|
|
|
// Before.
|
|
printf("** Load [enchant]\n");
|
|
DNTableFileFormat * pTableBefore = new DNTableFileFormat;
|
|
pTableBefore->Load( "out/enchanttable.dnt" );
|
|
pTableBefore->SetLoadName( "enchanttable.dnt" );
|
|
|
|
|
|
|
|
|
|
// Main Table.
|
|
printf("** Load [enchantMain.dnt]\n");
|
|
DNTableFileFormat * pTableMain = new DNTableFileFormat;
|
|
pTableMain->Load( "out/enchantmaintable.dnt" );
|
|
pTableMain->SetLoadName( "enchantmaintable.dnt" );
|
|
int sizeMain = pTableMain->GetItemCount();
|
|
int fieldCntMain = pTableMain->GetFieldCount();
|
|
|
|
// State.
|
|
printf("** Load [enchantMaxState.dnt]\n");
|
|
DNTableFileFormat * pTableState = new DNTableFileFormat;
|
|
pTableState->Load( "out/enchantmaxstatetable.dnt" );
|
|
pTableState->SetLoadName( "enchantmaxstatetable.dnt" );
|
|
|
|
// NeedItem.
|
|
printf("** Load [enchantNeedItem.dnt]\n");
|
|
DNTableFileFormat * pTableNeedItem = new DNTableFileFormat;
|
|
pTableNeedItem->Load( "out/enchantneeditemtable.dnt" );
|
|
pTableNeedItem->SetLoadName( "enchantneeditemtable.dnt" );
|
|
|
|
|
|
//// Main Table Data 컨테이너 설정.
|
|
//g_newTable.reserve( sizeMain );
|
|
//for( int i=0; i<sizeMain; ++i )
|
|
//{
|
|
// vector< SCell > * pVec = new vector< SCell >;
|
|
// pVec->reserve( pTableBefore->GetFieldCount() );
|
|
// g_newTable.push_back( pVec );
|
|
//}
|
|
|
|
|
|
//----------------------------------------------------------
|
|
// 나뉜 테이블을 하나로 취합.
|
|
//
|
|
DNTableCell * pTempCell = NULL;
|
|
printf("\n** 데이타통합 [enchantMaxState--enchantMain--enchantNeedItem]\n");
|
|
for( int i=0; i<sizeMain; ++i )
|
|
{
|
|
int mainItemID = pTableMain->GetItemID( i );
|
|
|
|
// 1행 데이터 벡터.
|
|
//vector< SCell > * pVecRow = g_newTable[ i ];
|
|
vector< SCell > * pVecRow = new vector< SCell >;
|
|
|
|
// 1행 채우기.
|
|
for( int fidx=0; fidx<fieldCntMain; ++fidx )
|
|
{
|
|
const char * fieldNameRef = NULL;
|
|
const char * fieldNameMain = pTableMain->GetFieldLabel( fidx );
|
|
|
|
SCell aCell;
|
|
DNTableCell * pTableCell = pTableMain->GetFieldFromLablePtr( mainItemID, fieldNameMain );
|
|
DNTableCell * pTableCellEnchantID = pTableMain->GetFieldFromLablePtr( mainItemID, "_EnchantID" ); // EnchantID.
|
|
DNTableCell * pTableCellEnchantLevel = pTableMain->GetFieldFromLablePtr( mainItemID, "_EnchantLevel" ); // EnchantLevel.
|
|
|
|
//pTableMain->getfield
|
|
|
|
aCell.mainID = mainItemID;
|
|
aCell.enchantID = pTableCellEnchantID->GetInteger();
|
|
aCell.enchatLevel = pTableCellEnchantLevel->GetInteger();
|
|
|
|
|
|
//if( _stricmp( fieldNameMain, "_EnchantID" ) == 0 ||
|
|
// _stricmp( fieldNameMain, "_EnchantLevel" ) == 0 ||
|
|
// _stricmp( fieldNameMain, "_NeedCoin" ) == 0 ||
|
|
// _stricmp( fieldNameMain, "_DisjointDrop" ) == 0 )
|
|
|
|
|
|
|
|
// NeedItem Table.
|
|
if( _stricmp( fieldNameMain, "_NeedItemTableID" ) == 0 )
|
|
{
|
|
int itemID_Need = pTableCell->GetInteger();
|
|
for( int idxneedfield=0; idxneedfield<pTableNeedItem->GetFieldCount(); ++idxneedfield )
|
|
{
|
|
const char * pNeedFieldName = pTableNeedItem->GetFieldLabel( idxneedfield );
|
|
|
|
// NeedItemTable 에만 존재하는"_UpStateRatio" 컬럼은 제외.
|
|
if( _stricmp( pNeedFieldName, "_UpStateRatio" ) != 0 )
|
|
{
|
|
pTempCell = pTableNeedItem->GetFieldFromLablePtr( itemID_Need, pTableNeedItem->GetFieldLabel(idxneedfield) );
|
|
|
|
aCell.id = itemID_Need;
|
|
aCell.name.assign( pNeedFieldName );
|
|
aCell.pData = pTempCell;
|
|
|
|
// 행에 한셀 데이터 추가.
|
|
pVecRow->push_back( aCell );
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// State Table.
|
|
else if( _stricmp( fieldNameMain, "_StateID" ) == 0 )
|
|
{
|
|
int itemID_State = pTableCell->GetInteger();
|
|
for( int idxstatefield=0; idxstatefield<pTableState->GetFieldCount(); ++idxstatefield )
|
|
{
|
|
const char * pStateFieldName = pTableState->GetFieldLabel( idxstatefield );
|
|
pTempCell = pTableState->GetFieldFromLablePtr( itemID_State, pStateFieldName );
|
|
|
|
aCell.id = itemID_State;
|
|
aCell.name.assign( pStateFieldName );
|
|
aCell.pData = pTableState->GetFieldFromLablePtr( itemID_State, pStateFieldName );
|
|
|
|
// 행에 한셀 데이터 추가.
|
|
pVecRow->push_back( aCell );
|
|
|
|
|
|
}
|
|
}
|
|
|
|
// 우선 [enchantMain] 과 [enchant] 의 비교는 제외. needcoin 과 disjointdrop 값이 서로 많이 다름.
|
|
// Main Table.
|
|
else
|
|
{
|
|
aCell.id = mainItemID;
|
|
aCell.name.assign( fieldNameMain );
|
|
aCell.pData = pTableCell;
|
|
|
|
// 행에 한셀 데이터 추가.
|
|
pVecRow->push_back( aCell );
|
|
}
|
|
|
|
}
|
|
|
|
g_newTable.insert( vNT::value_type( mainItemID, pVecRow ) );
|
|
}
|
|
|
|
|
|
// 필드명 등록. 데이타 타입구분용.
|
|
vector< string > vFieldNames;
|
|
vector< string >::iterator vFieldNameIt;
|
|
int fieldCnt_Before = pTableBefore->GetFieldCount();
|
|
for( int i=0; i<fieldCnt_Before; ++i )
|
|
{
|
|
vFieldNames.push_back( string( pTableBefore->GetFieldLabel( i ) ) );
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------
|
|
// 기존테이블 데이타와 비교.
|
|
//
|
|
printf("\n** 데이타비교 [enchant] VS [enchat NeedItem--Main--MaxState]\n");
|
|
FILE * fpOut = fopen("out\\different.txt", "w");
|
|
|
|
fprintf( fpOut, "enchantmain:%d, enchant:%d\n\n", g_newTable.size(), pTableBefore->GetItemCount() );
|
|
|
|
int nDiffCnt = 0;
|
|
for( int i=0; i<g_newTable.size(); ++i )
|
|
{
|
|
int itemID = pTableBefore->GetItemID( i ); // Before Table.
|
|
|
|
//vector< SCell > * pVecRow = g_newTable[ i ]; // newTableData vector.
|
|
|
|
vNT::iterator it = g_newTable.find( itemID );
|
|
if( it == g_newTable.end() )
|
|
continue;
|
|
vector< SCell > * pVecRow = (*it).second;
|
|
|
|
DNTableCell * pCellBefore = NULL;
|
|
|
|
for( int k=0; k<pVecRow->size(); ++k )
|
|
{
|
|
SCell & aCell = pVecRow->at( k );
|
|
|
|
// Field Data Type.
|
|
int idxField = GetFiledNameIndex( vFieldNames, aCell.name.c_str() );
|
|
if( idxField == -1 )
|
|
continue;
|
|
CDNTableFile::FieldType::eCode cFldType = pTableBefore->m_nVecFieldType[ idxField ];
|
|
|
|
|
|
// 기존데이타.
|
|
pCellBefore = pTableBefore->GetFieldFromLablePtr( itemID, aCell.name.c_str() );
|
|
|
|
|
|
// 둘다 NULL 인경우 무시.
|
|
if( aCell.pData == NULL && pCellBefore == NULL )
|
|
continue;
|
|
|
|
// NULL Data.
|
|
if( aCell.pData == NULL && pCellBefore != NULL )
|
|
{
|
|
//++nDiffCnt;
|
|
|
|
switch( cFldType ) {
|
|
case CDNTableFile::FieldType::eCode::STRING:
|
|
|
|
// [NULL]-[] 무시.
|
|
if( _stricmp( pCellBefore->GetString(), "0" ) != 0 )
|
|
{
|
|
++nDiffCnt;
|
|
fprintf( fpOut, "MainID[%7d], EnchantID[%7d], Level[%2d], RefID[%7d] : Row:%6d, {%15s} [ %s ]-[ %s ]\n",
|
|
aCell.mainID, aCell.enchantID, aCell.enchatLevel,
|
|
aCell.id, i, aCell.name.c_str(), "NULL", pCellBefore->GetString());
|
|
}
|
|
break;
|
|
|
|
case CDNTableFile::FieldType::eCode::BOOL:
|
|
case CDNTableFile::FieldType::eCode::NA:
|
|
++nDiffCnt;
|
|
fprintf( fpOut, "MainID[%7d], EnchantID[%7d], Level[%2d], RefID[%7d] : Row:%6d, {%15s} [ %s ]-[ %d ]\n",
|
|
aCell.mainID, aCell.enchantID, aCell.enchatLevel,
|
|
aCell.id, i, aCell.name.c_str(), "NULL", pCellBefore->GetInteger());
|
|
break;
|
|
|
|
|
|
case CDNTableFile::FieldType::eCode::INT:
|
|
|
|
// NULL / 0 허용.
|
|
if( pCellBefore->GetInteger() != 0 )
|
|
{
|
|
++nDiffCnt;
|
|
|
|
fprintf( fpOut, "MainID[%7d], EnchantID[%7d], Level[%2d], RefID[%7d] : Row:%6d, {%15s} [ %s ]-[ %d ]\n",
|
|
aCell.mainID, aCell.enchantID, aCell.enchatLevel,
|
|
aCell.id, i, aCell.name.c_str(), "NULL", pCellBefore->GetInteger());
|
|
|
|
}
|
|
break;
|
|
|
|
case CDNTableFile::FieldType::eCode::PER:
|
|
++nDiffCnt;
|
|
|
|
fprintf( fpOut, "MainID[%7d], EnchantID[%7d], Level[%2d], RefID[%7d] : Row:%6d, {%15s} [ %s ]-[ %.6f ]\n",
|
|
aCell.mainID, aCell.enchantID, aCell.enchatLevel,
|
|
aCell.id, i, aCell.name.c_str(), "NULL", pCellBefore->GetFloat());
|
|
break;
|
|
|
|
case CDNTableFile::FieldType::eCode::FLOAT:
|
|
|
|
// NULL / 0 허용.
|
|
if( pCellBefore->GetFloat() != 0.0f )
|
|
{
|
|
++nDiffCnt;
|
|
|
|
fprintf( fpOut, "MainID[%7d], EnchantID[%7d], Level[%2d], RefID[%7d] : Row:%6d, {%15s} [ %s ]-[ %.6f ]\n",
|
|
aCell.mainID, aCell.enchantID, aCell.enchatLevel,
|
|
aCell.id, i, aCell.name.c_str(), "NULL", pCellBefore->GetFloat());
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
switch( cFldType ) {
|
|
case CDNTableFile::FieldType::eCode::STRING:
|
|
if( _stricmp( aCell.pData->GetString(), pCellBefore->GetString() ) != 0 )
|
|
{
|
|
// []-[0] 무시.
|
|
if( (strlen( aCell.pData->GetString() ) < 1) &&
|
|
(_stricmp( pCellBefore->GetString(), "0" ) == 0) )
|
|
continue;
|
|
|
|
++nDiffCnt;
|
|
fprintf( fpOut, "MainID[%7d], EnchantID[%7d], Level[%2d], RefID[%7d] : Row:%6d, {%15s} [ %s ]-[ %s ]\n",
|
|
aCell.mainID, aCell.enchantID, aCell.enchatLevel,
|
|
aCell.id, i, aCell.name.c_str(), aCell.pData->GetString(), pCellBefore->GetString());
|
|
}
|
|
break;
|
|
|
|
case CDNTableFile::FieldType::eCode::BOOL:
|
|
case CDNTableFile::FieldType::eCode::NA:
|
|
if( aCell.pData->GetInteger() != pCellBefore->GetInteger() )
|
|
{
|
|
++nDiffCnt;
|
|
fprintf( fpOut, "MainID[%7d], EnchantID[%7d], Level[%2d], RefID[%7d] : Row:%6d, {%15s} [ %d ]-[ %d ]\n",
|
|
aCell.mainID, aCell.enchantID, aCell.enchatLevel,
|
|
aCell.id, i, aCell.name.c_str(), aCell.pData->GetInteger(), pCellBefore->GetInteger());
|
|
}
|
|
break;
|
|
|
|
case CDNTableFile::FieldType::eCode::INT:
|
|
{
|
|
// 1의 오차 허용.
|
|
int nValue = abs( aCell.pData->GetInteger() - pCellBefore->GetInteger() );
|
|
if( nValue > 1 )
|
|
//if( aCell.pData->GetInteger() != pCellBefore->GetInteger() )
|
|
{
|
|
++nDiffCnt;
|
|
fprintf( fpOut, "MainID[%7d], EnchantID[%7d], Level[%2d], RefID[%7d] : Row:%6d, {%15s} [ %d ]-[ %d ]\n",
|
|
aCell.mainID, aCell.enchantID, aCell.enchatLevel,
|
|
aCell.id, i, aCell.name.c_str(), aCell.pData->GetInteger(), pCellBefore->GetInteger());
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CDNTableFile::FieldType::eCode::PER:
|
|
case CDNTableFile::FieldType::eCode::FLOAT:
|
|
|
|
int fValue = fabs( aCell.pData->GetFloat() - pCellBefore->GetFloat() );
|
|
|
|
// 1의 오차 허용.
|
|
//if( aCell.pData->GetFloat() != pCellBefore->GetFloat() )
|
|
if( fValue > 1.0f )
|
|
{
|
|
++nDiffCnt;
|
|
fprintf( fpOut, "MainID[%7d], EnchantID[%7d], Level[%2d], RefID[%7d] : Row:%6d, {%15s} [ %f ]-[ %.6f ]\n",
|
|
aCell.mainID, aCell.enchantID, aCell.enchatLevel,
|
|
aCell.id, i, aCell.name.c_str(), aCell.pData->GetFloat(), pCellBefore->GetFloat());
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
fprintf( fpOut, "\n*** Different Count : %d", nDiffCnt);
|
|
fclose( fpOut );
|
|
//-------------
|
|
|
|
|
|
printf("** 총 %d 개 데이타 다름\n", nDiffCnt);
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------
|
|
// 출력용.
|
|
|
|
//char * str[32];
|
|
//FILE * fp = fopen("out\\data.txt", "w");
|
|
//fprintf( fp, "Size : %d ", g_newTable.size() );
|
|
|
|
|
|
//// 컬럼명.
|
|
//vector< SCell > * pVecRowTemp = g_newTable[ 0 ];
|
|
//for( int x=0; x<pVecRowTemp->size(); ++x )
|
|
//{
|
|
// fprintf( fp, "%s ", pVecRowTemp->at(x).name.c_str() );
|
|
//}
|
|
|
|
//for( int i=0; i<g_newTable.size(); ++i )
|
|
//{
|
|
// memset(str,0,32);
|
|
// vector< SCell > * pVecRow = g_newTable[ i ];
|
|
// fprintf( fp, "%d : ", i);
|
|
|
|
// for( int k=0; k<pVecRow->size(); ++k )
|
|
// {
|
|
// SCell & aCell = pVecRow->at( k );
|
|
// if( aCell.pData == NULL )
|
|
// {
|
|
// fprintf( fp, "NULL ");
|
|
// continue;
|
|
// }
|
|
|
|
// int idxField = GetFiledNameIndex( vFieldNames, aCell.name.c_str() );
|
|
// if( idxField == -1 )
|
|
// continue;
|
|
|
|
// char cFldType = (char)pTableBefore->m_nVecFieldType[ idxField ];
|
|
//
|
|
// switch( cFldType ) {
|
|
// case CSOXFile::FT_STRING:
|
|
// fprintf( fp, "%s ", aCell.pData->GetString() );
|
|
// break;
|
|
|
|
// case CSOXFile::FT_BOOL:
|
|
// case CSOXFile::FT_NA:
|
|
// case CSOXFile::FT_INT:
|
|
// fprintf( fp, "%d ", aCell.pData->GetInteger() );
|
|
// break;
|
|
|
|
// case CSOXFile::FT_PER:
|
|
// case CSOXFile::FT_FLOAT:
|
|
// fprintf( fp, "%f ", aCell.pData->GetFloat() );
|
|
// break;
|
|
// }
|
|
// }
|
|
|
|
// fprintf( fp, "\n");
|
|
//}
|
|
//fclose( fp );
|
|
|
|
|
|
|
|
//------------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
//------------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// g_newTable 제거.
|
|
/*for( int i=0; i<g_newTable.size(); ++i )
|
|
{
|
|
g_newTable[ i ]->clear();
|
|
delete g_newTable[ i ];
|
|
}*/
|
|
vNT::iterator it = g_newTable.begin();
|
|
for( ; it != g_newTable.end(); it++ )
|
|
{
|
|
(*it).second->clear();
|
|
delete (*it).second;
|
|
}
|
|
g_newTable.clear();
|
|
|
|
|
|
//// Table 제거.
|
|
//for( int i=0; i<vTables.size(); ++i )
|
|
// delete vTables[ i ];
|
|
//vTables.clear();
|
|
|
|
|
|
} |