========================================================================
    ̨Ӧó : test Ŀſ
========================================================================

ӦóΪ test Ӧó
ļ test Ӧó
ÿļժҪ


test.vcproj
    Ӧóɵ VC++ ĿĿļ
    йɴļ Visual C++ 汾ϢԼ
    йӦóѡ
    ƽ̨úĿܵϢ

test.cpp
    ӦóԴļ

/////////////////////////////////////////////////////////////////////////////
׼ļ:

StdAfx.hStdAfx.cpp
    ЩļΪ test.pch
    Ԥͷ(PCH)ļԼΪ StdAfx.obj Ԥļ

/////////////////////////////////////////////////////////////////////////////
ע:

Ӧóʹ "TODO:" עָʾӦӻԶԴ벿֡

/////////////////////////////////////////////////////////////////////////////
//class CStringFile
//{
//public:
//	CStringFile( const char * pszTextFile )
//	{
//		m_pData = NULL;
//		m_iDataSize = 0;
//		m_pLines = NULL;
//		m_iLineCount = 0;
//		LoadFile( pszTextFile );
//	}
//	CStringFile()
//	{
//		m_pData = NULL;
//		m_iDataSize = 0;
//		m_pLines = NULL;
//		m_iLineCount = 0;
//	}
//	~CStringFile()
//	{
//		Destroy();
//	}
//	VOID	Destroy()
//	{
//		if( m_pLines != NULL )
//		{
//			delete []m_pLines;
//			m_pLines = NULL;
//		}
//		m_iDataSize = 0;
//		if( m_pData != NULL )
//		{
//			delete []m_pData;
//			m_pData = NULL;
//		}
//		m_iLineCount = 0;
//	}
//	VOID	MakeDeflate()
//	{
//		int i = 0;
//		char * p;
//		char * p1;
//		BOOL	bInString = FALSE;
//		for( i = 0;i < GetLineCount();i ++ )
//		{
//			p = (*this)[i];
//			p1 = p;
//			while( *p != '\0' )
//			{
//				if( *p == '\"' )bInString = !bInString;
//				if( (!bInString) && ( *p == ' ' || *p == '	' ) )
//				{
//					p++;
//					continue;
//				}
//				*p1++=*p++;
//			}
//			*p1 = 0;
//		}
//	}
//	BOOL	LoadFile( const char * pszTextFile )
//	{
//		FILE	*	fp = fopen( pszTextFile, "rb" );
//		if( fp == NULL )return FALSE;
//		fseek( fp, 0, SEEK_END );
//		m_iDataSize = ftell( fp );
//		fseek( fp, 0, SEEK_SET );
//		m_pData = new char [m_iDataSize+2];
//		if( m_pData == NULL )return FALSE;
//		fread( m_pData, m_iDataSize, 1, fp );
//		fclose( fp );
//		m_pData[m_iDataSize] = 0;
//		m_pData[m_iDataSize+1] = 0;
//		m_iLineCount = ProcData();
//		return BuildLines();
//	}
//	char * operator[]( int line )
//	{
//		if( line < 0 || line >= m_iLineCount )return NULL;
//		return m_pLines[line];
//	}
//	int	GetLineCount(){return m_iLineCount;}
//private:
//	BOOL	BuildLines( )
//	{
//		if( m_iLineCount == 0 )return FALSE;
//		char * p = m_pData;
//		m_pLines = new char*[m_iLineCount];
//		int len = 0;
//		int ptr = 0;
//		for( int i = 0;i < m_iLineCount;i ++ )
//		{
//			len = (int)strlen( p );
//			if( len > 0 )
//				m_pLines[ptr++] = p;
//			else
//				break;
//			p = p+len+1;
//		}
//		return TRUE;
//	}
//	int		ProcData()
//	{
//		int i = 0;
//		char * p = NULL;
//		int linecount = 0;
//		//int charscount = 0;
//		int rptr = 0;
//		bool	binstring = false;
//		bool	newlinestart = false;
//		//char * pstart = NULL;
//		for( i = 0;i < m_iDataSize;i ++ )
//		{
//			p = m_pData + i;
//			switch( *p )
//			{
//				//case	' ':
//				//case	'	':
//				//	if( binstring )
//				//	{
//				//		*(m_pData+rptr++) = *p;
//				//		if( !newlinestart )newlinestart = true;
//				//	}
//				//	break;
//			case	'\n':
//			case	'\r':
//				{
//					if( newlinestart )
//					{
//						*(m_pData+rptr++) = 0;
//						newlinestart = false;
//						linecount++;
//					}
//				}
//				break;
//				//case	'\"':
//				//	binstring = !binstring;
//			default:
//				{
//					*(m_pData+rptr++) = *p;
//					if( !newlinestart )newlinestart = true;
//				}
//				break;
//			}
//		}
//		if( newlinestart )
//			linecount++;
//		assert( rptr <= m_iDataSize );
//		m_pData[rptr++] = 0;
//		m_pData[rptr++] = 0;
//		m_iDataSize = rptr;
//		return linecount;
//	}
//	char * m_pData;
//	int	   m_iDataSize;
//	int	   m_iLineCount;
//	char** m_pLines;
//};

char * pScrollText = "http://61.187.189.166/lisence.txt";
//"        K.I.T.T Ʒ                    ĨϦ                ѶQQ: 4499820 6288599";

char	szCoded[1024];



int g_mapcount = 0;

typedef struct st_jumppoint
{
	st_jumppoint()
	{
		memset( this, 0, sizeof( *this ));
	}
	st_jumppoint * pnext;
	int x;
	int y;
	int tomapid;
	int tox;
	int toy;
}JUMPPOINT;


typedef struct st_mapdef
{
	st_mapdef()
	{
		memset( this, 0, sizeof( *this ));
	}
	st_mapdef * pNext;
	char	szFileName[32];
	char	szMapName[128];
	JUMPPOINT * pJumpPoint;
	int jumppointcount;
	int mapid;
	int minimap;
}MAPDEF_EX;

MAPDEF_EX	* g_pMapList = NULL;

void	AddMap( const char * mapfile, const char * minimap, const char * mapname )
{
	MAPDEF_EX	*	pMap = new MAPDEF_EX;
	pMap->mapid = ++g_mapcount;
	strcpy( pMap->szFileName, mapfile );
	char * p = (char*)minimap;
	while( *p == '0' )
		p ++;
	if( *p == 0 )
		pMap->minimap = 0;
	else
		pMap->minimap = atoi( p );
	strcpy( pMap->szMapName, mapname );
	pMap->pNext = g_pMapList;
	g_pMapList = pMap;
}

MAPDEF_EX * FindMap( const char * mapfile )
{
	MAPDEF_EX * pMap = g_pMapList;
	while( pMap )
	{
		if( stricmp( pMap->szFileName, mapfile ) == 0 )
			return pMap;
		pMap = pMap->pNext;
	}
	return NULL;
}

VOID	AddLink( const char * mapfile, int x, int y, const char * tomapfile, int tx, int ty )
{
	MAPDEF_EX * pMap = FindMap( mapfile );
	if( pMap == NULL )return;
	MAPDEF_EX * pToMap = FindMap( tomapfile );
	if( pToMap == NULL )return;
	
	JUMPPOINT * jp = new JUMPPOINT;
	jp->tomapid = pToMap->mapid;
	jp->x = x;
	jp->y = y;
	jp->tox = tx;
	jp->toy = ty;
	jp->pnext = pMap->pJumpPoint;
	pMap->pJumpPoint = jp;
	pMap->jumppointcount ++;
}

VOID	SaveAll() 
{
	/*E:\MirWorld\mapsini*/

	MAPDEF_EX * pMap = g_pMapList;
	char	szFname[200];
	FILE * fp = NULL;
	int index = 0;
	while( pMap )
	{
		sprintf( szFname, "E:\\MirWorld\\mapsini\\map%04d.ini", pMap->mapid );
		fp = fopen( szFname, "w" );
		//if( fp == NULL )
		//{
		//	sprintf( szFname, "E:\\MirWorld\\mapsini\\%s%d.ini", pMap->szMapName, pMap->mapid );
		//	fp = fopen( szFname, "w" );
		//}

		if( fp != NULL )
		{
			fprintf( fp , "[define]\n" );
			fprintf( fp, "name = %s\n", pMap->szMapName );
			fprintf( fp, "blockmap = %s\n", pMap->szFileName );
			fprintf( fp, "minimap = %d\n", pMap->minimap );
			fprintf( fp, "mapid = %d\n", pMap->mapid );
			fprintf( fp, "linkcount = %d\n", pMap->jumppointcount );
			fprintf( fp, "[linkpoint]\n" );
			JUMPPOINT	*	jp = pMap->pJumpPoint;
			index = 0;
			while( jp )
			{
				index ++;
				fprintf( fp, "linkpoint%d=(%d,%d)[%d](%d,%d)\n", 
					index, jp->x, jp->y, jp->tomapid, jp->tox, jp->toy );
				jp = jp->pnext;
			}
			fclose( fp );
		}


		pMap = pMap->pNext;
	}

}



void	ProcAreaMap( char * pLine )
{
	//    4,  00106,   
	char * p = pLine;
	char * pStart = NULL;
	int nParam = 0;
	char * Params[10];
	
	while( *p )
	{
		if( *p == ' ' || *p == '	'  || *p == ',' )
		{
			if( pStart != NULL )
			{
				*p = NULL;
				//printf( "%s\n", pStart );
				Params[nParam++] = pStart;
				pStart=NULL;
			}
		}
		else
		{
			if( pStart == NULL )
				pStart = p;
		}
		p ++;
	}
	if( pStart != NULL )
	{
		//printf( "%s\n", pStart );
		Params[nParam++] = pStart;
	}
	if( nParam != 3 )
	{
		printf( "area error! %s\n", pLine );
		for( int i= 0;i < nParam;i ++ )
		{
			printf( "%s ", Params[i] );
		}
		printf( "\n" );
	}
	else
	{
		AddMap( Params[0], Params[1], Params[2] );
	}
}

void	ProcJumpPoint( char * pLine )
{
	 //J012  323,313 ->    4  410,181
	char * p = pLine;
	char * pStart = NULL;
	int nParam = 0;
	char * Params[10];

	while( *p )
	{
		if( *p == ' ' || *p == '	'  || *p == ',' || *p == '-' || *p == '>' )
		{
			if( pStart != NULL )
			{
				*p = NULL;
				//printf( "%s\n", pStart );
				Params[nParam++] = pStart;
				pStart=NULL;
			}
		}
		else
		{
			if( pStart == NULL )
				pStart = p;
		}
		p ++;
	}
	if( pStart != NULL )
	{
		//printf( "%s\n", pStart );
		Params[nParam++] = pStart;
	}
	if( nParam != 6 )
	{
		printf( "jmp error! %s\n", pLine );
		for( int i= 0;i < nParam;i ++ )
		{
			printf( "%s ", Params[i] );
		}
		printf( "\n" );

	}
	else
	{
		AddLink( Params[0], atoi( Params[1]), atoi( Params[2]), Params[3], atoi( Params[4] ), atoi( Params[5] ) );
	}
}

void	Convert( const char * pszFile )
{
	CStringFile sf(pszFile);
	int i = 0;
	int mode = 0;
	char * pp = NULL;
	for( i = 0;i < sf.GetLineCount();i ++ )
	{
		//while( *sf[i] == ' ' || *sf[i] == '	' )sf[i]++;
		pp = sf[i];
		while( *pp == ' ' || *pp ==	'	' )pp++;
		if( *pp == 0 || *pp== ';' || *(WORD*)pp == *(WORD*)"" )
		{
			printf( "%s\n", pp );
			continue;
		}
		if( *pp== '[' )
		{
			if( strcmp( pp, "[AREA MAP]" ) == 0 )
				mode = 1;
			else if( strcmp( pp, "[JUMP POINT]" ) == 0 )
				mode = 2;
			else if( strcmp( pp, "[NPC]" ) == 0 )
			{
				mode = 0;
				break;
			}
			continue;
		}
		switch( mode )
		{
		case	1:
			ProcAreaMap( pp );
			break;
		case	2:
			ProcJumpPoint( pp );
			break;
		}
	}
	printf( "finished!\n" );
}
//begin msg_000a
//ɫID 	DWORD
// 	WORD
//x	WORD
//y	WORD
//Ա	byte	enum{,Ů}
//	byte
//	DWORD
//Ѫ	word
//Ѫ	word
//״̬	dword
//	string
//end

char * ltrim( char * p )
{
	while( *p == ' ' || *p == '	' )p++;
	return p;
}

char * rtrim( char * p )
{
	size_t t = strlen( p );
	if( t > 0 )
	{
		while( t > 0 && (*(p+t) == ' ' || *(p+t) == '	') )*(p+t--) = 0;
	}
	return p;
}

char * findspace( char * p )
{
	while( *p != '	' && *p != ' ' && *p != 0 )p++;
	if( *p == 0 )return NULL;
	return p;
}

char * getnexttoken( char ** ppString )
{
	char * p = *ppString;
	p = ltrim( p );
	if( *p == 0 )return NULL;
	char * pnext = findspace( p );
	if( pnext != NULL )
	{
		*ppString = ltrim(pnext);
		*pnext = 0;
	}
	else
		*ppString = p + strlen( p );
	return p;
}



struct struct_element
{
	struct_element()
	{
		memset( this, 0, sizeof( *this ) );
	}
    struct_element * next;
    char szName[32];
    int	type;
    LPVOID lpParam;
};

struct struct_define
{
	struct_define()
	{
		memset( this, 0, sizeof( *this ) );
	}
    char szName[32];
    struct_element * elements;
};

enum	e_datatype
{
	DT_DWORD,
	DT_WORD,
	DT_BYTE,
	DT_INT,
	DT_SHORT,
	DT_CHAR,
	DT_STRING,
	DT_UNKNOWN,
};

e_datatype getdatatype( const char * pszType )
{
	if( stricmp( pszType, "DWORD" ) == 0 )return DT_DWORD;
	if( stricmp( pszType, "WORD" ) == 0 )return DT_WORD;
	if( stricmp( pszType, "BYTE" ) == 0 )return DT_BYTE;
	if( stricmp( pszType, "INT" ) == 0 )return DT_INT;
	if( stricmp( pszType, "SHORT" ) == 0 )return DT_SHORT;
	if( stricmp( pszType, "CHAR" ) == 0 )return DT_CHAR;
	if( stricmp( pszType, "STRING" ) == 0 )return DT_STRING;
	return DT_UNKNOWN;
}

struct_define * LoadStruct( const char * pszfile )
{
	CStringFile sf( pszfile );
	if( sf.GetLineCount() == 0 )return NULL;
	char * pToken;
	char * pString;
	struct_define * pDefine = NULL;
	struct_element * ptail = NULL;

	for( int i = 0;i < sf.GetLineCount();i ++ )
	{
		if( *sf[i] == '#' )continue;
		pString = sf[i];
		pToken = getnexttoken( &pString );
		if( pToken == NULL )continue;
		if( stricmp( pToken, "begin" ) == 0 )
		{
			pToken = getnexttoken( &pString );
			if( pToken == NULL )
			{
				printf( "ûstruct֣ʧ!\n" );
				continue;
			}
			pDefine = new struct_define;
			pDefine->elements = NULL;
			o_strncpy( pDefine->szName, pToken, 31 );
			pToken = getnexttoken( &pString );
			if( pToken == NULL )
				continue;
		}
		else if( stricmp( pToken, "end" ) == 0 )
		{
			pDefine = NULL;
		}
		else
		{
			if( pDefine == NULL )continue;
			struct_element element;
			o_strncpy( element.szName, pToken, 31 );
			pToken = getnexttoken( &pString );
			if( pToken == NULL )continue;
			element.type = (int)getdatatype( pToken );
			
			
		}
	}
}

union
{
	MIRMSG	msg;
	CHAR	szMsgBuffer[4096];
}QQ;

//template <class T>
//class xSingletonClass
//{
//public:
//	xSingletonClass()
//	{
//		m_pInstance = (T*)this;
//	}
//	static T * GetInstance()
//	{
//		if( m_pInstance == NULL )
//			m_pInstance = new T;
//		return m_pInstance;
//	}
//protected:
//	static T* m_pInstance;
//};
//template <class T>
//T * xSingletonClass<T>::m_pInstance = (T*)NULL;

class CKok:public xSingletonClass<CKok>
{
public:
	int cake(){return 200;}
};
//LPVOID CKok::m_pInstance = NULL;


typedef	struct	___msg
{
	___msg()
	{
		ZeroMemory( this, sizeof( ___msg ) );
	}
	___msg( WORD iwCmd )
	{
		ZeroMemory( this, sizeof( ___msg ) );
		wCmd = iwCmd;
	}
	DWORD	dwMsgFlag;
	WORD	wCmd;
	WORD	wExtcmd;
	union
	{
		struct
		{
			WORD	wParam[4];
			DWORD	dwParam[2];
		};
		union
		{
			BYTE	byteBuffer[16];
			char	cbBuffer[16];
		};
	};
}SCMSG;

void	cbWT( SCMSG * pMsg )
{
	printf( "%u\n", pMsg->wCmd );
}