// PacketHeaderListCP.cpp : 콘솔 응용 프로그램에 대한 진입점을 정의합니다.
//

#include "stdafx.h"

VOID OUTPUT_STYLE_WISE_CATEGORY( DWORD index, DWORD num )
{
	//printf( "CATEGORY_GENERATOR_%03d	=	%03d\n", num, CATEGORY_GENERATOR( INDEX_GENERATOR(index) ) );
	printf( "USER_%03d	=	%03d\n", num, CATEGORY_GENERATOR( INDEX_GENERATOR(index) ) );
}


VOID OUTPUT_STYLE_WISE_PROTOCOL( DWORD index, DWORD num )
{
	//printf( "PROTOCOL_GENERATOR_%03d	=	%03d\n", num, PROTOCOL_GENERATOR( INDEX_GENERATOR(index) ) );
	printf( "USER_%03d	=	%03d\n", num, PROTOCOL_GENERATOR( INDEX_GENERATOR(index) ) );
}

#define PACKET_CG_OPEN( c, p )	struct MSG_##p : public MSG_BASE { MSG_##p(){ m_byCategory = c; m_byProtocol = p; }
#define PACKET_CG_CLOSE		};

#pragma pack(push,1)

struct ADDITIONAL_CHUNTINGINFO
{
	BYTE		m_Difficulty	: 4;		//< eHUNTING_MONSTER_DIFFICULT 의 값
	BYTE		m_Bonus			: 4;		//< eHUNTING_BONUS_TYPE 의 값
	BYTE		m_Rule			: 4;		//< 룰 eCOMPETITION_RULE_TYPE(프리퍼올, 듀얼파티)
	BYTE		m_Mode			: 4;		//< 모드 eCOMPETITION_MODE_TYPE(서바이벌, 타임어택)
};

typedef WORD	SLOTCODE;

struct MSG_PROTO
{
	DWORD					m_dwKey;
};

struct MSG_BASE_INTERNAL
{
	BYTE						m_byCategory;	// 카테고리
	union
	{
		BYTE					m_byProtocol;		// 카테고리 아래의 타입
		BYTE					m_byEncryptedBuffer[1];		// 암호화된 버퍼
	};
};

struct MSG_BASE : public MSG_PROTO
{
	BYTE						m_byCategory;	// 카테고리
	union
	{
		BYTE					m_byProtocol;		// 카테고리 아래의 타입
		BYTE					m_byEncryptedBuffer[1];		// 암호화된 버퍼
	};
};

PACKET_CG_OPEN( CG_ZONE, CG_ZONE_LOBBY_CHUNTING_REQUEST_INFO_ACK )
SLOTCODE				m_MapCode;
ADDITIONAL_CHUNTINGINFO m_AdditionalCHuntingInfo;
BYTE					m_NonBlockNum	:4;
BYTE					m_Count			:4;
DWORD					m_dwReadyPlayerKey[/*MAX_PARTYMEMBER_NUM*/10];	//< 자기자신 불 포함 + 방장 불 포함
int						GetSize()
{
	return (sizeof(MSG_CG_ZONE_LOBBY_CHUNTING_REQUEST_INFO_ACK) - sizeof(DWORD)*(/*MAX_PARTYMEMBER_NUM*/10-m_Count));
}
PACKET_CG_CLOSE

#pragma pack(pop)


//int _tmain(int argc, _TCHAR* argv[])
//{
//	MSG_CG_ZONE_LOBBY_CHUNTING_REQUEST_INFO_ACK msg;
//
//	msg.m_Count = 0;
//
//	printf( "size %d %d\n", sizeof(msg), msg.GetSize() );
//
//	return 0;
//}

#include <Define.Build.h>
#include <Protocol_CG.h>
#include "Protocol_CG.HEAD.h"
#include "Protocol_CG.WRAP.h"
#include "Protocol_CG.TAIL.h"

BOOST_STATIC_ASSERT(CATEGORY_GENERATOR_036 == CG_MAX);
BOOST_STATIC_ASSERT(CATEGORY_GENERATOR_136 == CG_MAX_PACK);


static VOID		Output_Style_Catgories();

int _tmain(int argc, _TCHAR* argv[])
{
	switch( argc )
	{
	case 1:
		{
			Output_Style_Catgories();
			//printf( "[CATEGORY]\n" );
			//for( DWORD i=1 ; i<=256 ; ++i )
			//{
			//	OUTPUT_STYLE_WISE_CATEGORY( i, i );
			//}

			//printf( "[PROTOCOL]\n" );
			//int num = 0;
			//for( DWORD i=256 ; i>0 ; --i )
			//{
			//	OUTPUT_STYLE_WISE_PROTOCOL( i, ++num );
			//}
		}
		break;
	case 2:
		{
			// 특정 카테고리만 보기
			int en_category = atoi( argv[1] );
			if( (DWORD)en_category > 256 )
				return -1;

			int iFind = 0;
			const PROTOCOL_STRUCT_CATEINDEX* pPTR = &idxCG_CATEGORY[0];
			for(  ; iFind<256 ; ++iFind )
			{
				if( pPTR->pProtocols == NULL )
				{
					iFind = 256;
					break;
				}

				if( pPTR->dwIndex == en_category )
					break;

				pPTR++;
			}

			if( iFind==256 )
			{
				perror( "Can't find Category Number" );
				return -1;
			}

			printf( "%s\n", pPTR->pCategoryName );

		}
		break;
	case 3:
		{
			// 특정 카테고리/프로토콜에 대응되는 메시지를 보기
			int en_category = atoi( argv[1] );
			int en_protocol = atoi( argv[2] );

			if( (DWORD)en_category > 256 || (DWORD)en_protocol > 256 )
				return -1;

			int iFind = 0;
			const PROTOCOL_STRUCT_CATEINDEX* pPTR = &idxCG_CATEGORY[0];
			for(  ; iFind<256 ; ++iFind )
			{
				if( pPTR->pProtocols == NULL )
				{
					iFind = 256;
					break;
				}

				if( pPTR->dwIndex == en_category )
					break;

				pPTR++;
			}

			if( iFind==256 )
			{
				perror( "Can't find Category Number" );
				return -1;
			}

			CHAR* catename = pPTR->pCategoryName;
			const PROTOCOL_STRUCT* pProtocols = pPTR->pProtocols;

			for( iFind=0 ; iFind<256 ; ++iFind )
			{
				if( pProtocols->name == NULL )
				{
					iFind = 256;
					break;
				}

				if( pProtocols->code == (BYTE)en_protocol )
					break;

				pProtocols++;
			}

			printf( "MSG_%s\n", pProtocols->name );
		}
		break;
	};

	return 0;
}


static VOID		Output_Style_Catgories()
{
#define OUTPUT_CATEGORY(	no	)	\
	printf( "CATEGORY_GENERATOR_" #no "		- %03u\n", CATEGORY_GENERATOR_##no );

	OUTPUT_CATEGORY(	001	);
	OUTPUT_CATEGORY(	002	);
	OUTPUT_CATEGORY(	003	);
	OUTPUT_CATEGORY(	004	);
	OUTPUT_CATEGORY(	005	);
	OUTPUT_CATEGORY(	006	);
	OUTPUT_CATEGORY(	007	);
	OUTPUT_CATEGORY(	008	);
	OUTPUT_CATEGORY(	009	);
	OUTPUT_CATEGORY(	010	);
	OUTPUT_CATEGORY(	011	);
	OUTPUT_CATEGORY(	012	);
	OUTPUT_CATEGORY(	013	);
	OUTPUT_CATEGORY(	014	);
	OUTPUT_CATEGORY(	015	);
	OUTPUT_CATEGORY(	016	);
	OUTPUT_CATEGORY(	017	);
	OUTPUT_CATEGORY(	018	);
	OUTPUT_CATEGORY(	019	);
	OUTPUT_CATEGORY(	020	);
	OUTPUT_CATEGORY(	021	);
	OUTPUT_CATEGORY(	022	);
	OUTPUT_CATEGORY(	023	);
	OUTPUT_CATEGORY(	024	);
	OUTPUT_CATEGORY(	025	);
	OUTPUT_CATEGORY(	026	);
	OUTPUT_CATEGORY(	027	);
	OUTPUT_CATEGORY(	028	);
	OUTPUT_CATEGORY(	029	);
	OUTPUT_CATEGORY(	030	);
	OUTPUT_CATEGORY(	031	);
	OUTPUT_CATEGORY(	032	);
	OUTPUT_CATEGORY(	033	);
	OUTPUT_CATEGORY(	034	);
	OUTPUT_CATEGORY(	035	);
	OUTPUT_CATEGORY(	036	);
	OUTPUT_CATEGORY(	037	);
	OUTPUT_CATEGORY(	038	);
	OUTPUT_CATEGORY(	039	);
	OUTPUT_CATEGORY(	040	);
	OUTPUT_CATEGORY(	041	);
	OUTPUT_CATEGORY(	042	);
	OUTPUT_CATEGORY(	043	);
	OUTPUT_CATEGORY(	044	);
	OUTPUT_CATEGORY(	045	);
	OUTPUT_CATEGORY(	046	);
	OUTPUT_CATEGORY(	047	);
	OUTPUT_CATEGORY(	048	);
	OUTPUT_CATEGORY(	049	);
	OUTPUT_CATEGORY(	050	);
	OUTPUT_CATEGORY(	051	);
	OUTPUT_CATEGORY(	052	);
	OUTPUT_CATEGORY(	053	);
	OUTPUT_CATEGORY(	054	);
	OUTPUT_CATEGORY(	055	);
	OUTPUT_CATEGORY(	056	);
	OUTPUT_CATEGORY(	057	);
	OUTPUT_CATEGORY(	058	);
	OUTPUT_CATEGORY(	059	);
	OUTPUT_CATEGORY(	060	);
	OUTPUT_CATEGORY(	061	);
	OUTPUT_CATEGORY(	062	);
	OUTPUT_CATEGORY(	063	);
	OUTPUT_CATEGORY(	064	);
	OUTPUT_CATEGORY(	065	);
	OUTPUT_CATEGORY(	066	);
	OUTPUT_CATEGORY(	067	);
	OUTPUT_CATEGORY(	068	);
	OUTPUT_CATEGORY(	069	);
	OUTPUT_CATEGORY(	070	);
	OUTPUT_CATEGORY(	071	);
	OUTPUT_CATEGORY(	072	);
	OUTPUT_CATEGORY(	073	);
	OUTPUT_CATEGORY(	074	);
	OUTPUT_CATEGORY(	075	);
	OUTPUT_CATEGORY(	076	);
	OUTPUT_CATEGORY(	077	);
	OUTPUT_CATEGORY(	078	);
	OUTPUT_CATEGORY(	079	);
	OUTPUT_CATEGORY(	080	);
	OUTPUT_CATEGORY(	081	);
	OUTPUT_CATEGORY(	082	);
	OUTPUT_CATEGORY(	083	);
	OUTPUT_CATEGORY(	084	);
	OUTPUT_CATEGORY(	085	);
	OUTPUT_CATEGORY(	086	);
	OUTPUT_CATEGORY(	087	);
	OUTPUT_CATEGORY(	088	);
	OUTPUT_CATEGORY(	089	);
	OUTPUT_CATEGORY(	090	);
	OUTPUT_CATEGORY(	091	);
	OUTPUT_CATEGORY(	092	);
	OUTPUT_CATEGORY(	093	);
	OUTPUT_CATEGORY(	094	);
	OUTPUT_CATEGORY(	095	);
	OUTPUT_CATEGORY(	096	);
	OUTPUT_CATEGORY(	097	);
	OUTPUT_CATEGORY(	098	);
	OUTPUT_CATEGORY(	099	);
	OUTPUT_CATEGORY(	100	);
	OUTPUT_CATEGORY(	101	);
	OUTPUT_CATEGORY(	102	);
	OUTPUT_CATEGORY(	103	);
	OUTPUT_CATEGORY(	104	);
	OUTPUT_CATEGORY(	105	);
	OUTPUT_CATEGORY(	106	);
	OUTPUT_CATEGORY(	107	);
	OUTPUT_CATEGORY(	108	);
	OUTPUT_CATEGORY(	109	);
	OUTPUT_CATEGORY(	110	);
	OUTPUT_CATEGORY(	111	);
	OUTPUT_CATEGORY(	112	);
	OUTPUT_CATEGORY(	113	);
	OUTPUT_CATEGORY(	114	);
	OUTPUT_CATEGORY(	115	);
	OUTPUT_CATEGORY(	116	);
	OUTPUT_CATEGORY(	117	);
	OUTPUT_CATEGORY(	118	);
	OUTPUT_CATEGORY(	119	);
	OUTPUT_CATEGORY(	120	);
	OUTPUT_CATEGORY(	121	);
	OUTPUT_CATEGORY(	122	);
	OUTPUT_CATEGORY(	123	);
	OUTPUT_CATEGORY(	124	);
	OUTPUT_CATEGORY(	125	);
	OUTPUT_CATEGORY(	126	);
	OUTPUT_CATEGORY(	127	);
	OUTPUT_CATEGORY(	128	);
	OUTPUT_CATEGORY(	129	);
	OUTPUT_CATEGORY(	130	);
	OUTPUT_CATEGORY(	131	);
	OUTPUT_CATEGORY(	132	);
	OUTPUT_CATEGORY(	133	);
	OUTPUT_CATEGORY(	134	);
	OUTPUT_CATEGORY(	135	);
	OUTPUT_CATEGORY(	136	);
	OUTPUT_CATEGORY(	137	);
	OUTPUT_CATEGORY(	138	);
	OUTPUT_CATEGORY(	139	);
	OUTPUT_CATEGORY(	140	);
	OUTPUT_CATEGORY(	141	);
	OUTPUT_CATEGORY(	142	);
	OUTPUT_CATEGORY(	143	);
	OUTPUT_CATEGORY(	144	);
	OUTPUT_CATEGORY(	145	);
	OUTPUT_CATEGORY(	146	);
	OUTPUT_CATEGORY(	147	);
	OUTPUT_CATEGORY(	148	);
	OUTPUT_CATEGORY(	149	);
	OUTPUT_CATEGORY(	150	);
	OUTPUT_CATEGORY(	151	);
	OUTPUT_CATEGORY(	152	);
	OUTPUT_CATEGORY(	153	);
	OUTPUT_CATEGORY(	154	);
	OUTPUT_CATEGORY(	155	);
	OUTPUT_CATEGORY(	156	);
	OUTPUT_CATEGORY(	157	);
	OUTPUT_CATEGORY(	158	);
	OUTPUT_CATEGORY(	159	);
	OUTPUT_CATEGORY(	160	);
	OUTPUT_CATEGORY(	161	);
	OUTPUT_CATEGORY(	162	);
	OUTPUT_CATEGORY(	163	);
	OUTPUT_CATEGORY(	164	);
	OUTPUT_CATEGORY(	165	);
	OUTPUT_CATEGORY(	166	);
	OUTPUT_CATEGORY(	167	);
	OUTPUT_CATEGORY(	168	);
	OUTPUT_CATEGORY(	169	);
	OUTPUT_CATEGORY(	170	);
	OUTPUT_CATEGORY(	171	);
	OUTPUT_CATEGORY(	172	);
	OUTPUT_CATEGORY(	173	);
	OUTPUT_CATEGORY(	174	);
	OUTPUT_CATEGORY(	175	);
	OUTPUT_CATEGORY(	176	);
	OUTPUT_CATEGORY(	177	);
	OUTPUT_CATEGORY(	178	);
	OUTPUT_CATEGORY(	179	);
	OUTPUT_CATEGORY(	180	);
	OUTPUT_CATEGORY(	181	);
	OUTPUT_CATEGORY(	182	);
	OUTPUT_CATEGORY(	183	);
	OUTPUT_CATEGORY(	184	);
	OUTPUT_CATEGORY(	185	);
	OUTPUT_CATEGORY(	186	);
	OUTPUT_CATEGORY(	187	);
	OUTPUT_CATEGORY(	188	);
	OUTPUT_CATEGORY(	189	);
	OUTPUT_CATEGORY(	190	);
	OUTPUT_CATEGORY(	191	);
	OUTPUT_CATEGORY(	192	);
	OUTPUT_CATEGORY(	193	);
	OUTPUT_CATEGORY(	194	);
	OUTPUT_CATEGORY(	195	);
	OUTPUT_CATEGORY(	196	);
	OUTPUT_CATEGORY(	197	);
	OUTPUT_CATEGORY(	198	);
	OUTPUT_CATEGORY(	199	);
	OUTPUT_CATEGORY(	200	);
	OUTPUT_CATEGORY(	201	);
	OUTPUT_CATEGORY(	202	);
	OUTPUT_CATEGORY(	203	);
	OUTPUT_CATEGORY(	204	);
	OUTPUT_CATEGORY(	205	);
	OUTPUT_CATEGORY(	206	);
	OUTPUT_CATEGORY(	207	);
	OUTPUT_CATEGORY(	208	);
	OUTPUT_CATEGORY(	209	);
	OUTPUT_CATEGORY(	210	);
	OUTPUT_CATEGORY(	211	);
	OUTPUT_CATEGORY(	212	);
	OUTPUT_CATEGORY(	213	);
	OUTPUT_CATEGORY(	214	);
	OUTPUT_CATEGORY(	215	);
	OUTPUT_CATEGORY(	216	);
	OUTPUT_CATEGORY(	217	);
	OUTPUT_CATEGORY(	218	);
	OUTPUT_CATEGORY(	219	);
	OUTPUT_CATEGORY(	220	);
	OUTPUT_CATEGORY(	221	);
	OUTPUT_CATEGORY(	222	);
	OUTPUT_CATEGORY(	223	);
	OUTPUT_CATEGORY(	224	);
	OUTPUT_CATEGORY(	225	);
	OUTPUT_CATEGORY(	226	);
	OUTPUT_CATEGORY(	227	);
	OUTPUT_CATEGORY(	228	);
	OUTPUT_CATEGORY(	229	);
	OUTPUT_CATEGORY(	230	);
	OUTPUT_CATEGORY(	231	);
	OUTPUT_CATEGORY(	232	);
	OUTPUT_CATEGORY(	233	);
	OUTPUT_CATEGORY(	234	);
	OUTPUT_CATEGORY(	235	);
	OUTPUT_CATEGORY(	236	);
	OUTPUT_CATEGORY(	237	);
	OUTPUT_CATEGORY(	238	);
	OUTPUT_CATEGORY(	239	);
	OUTPUT_CATEGORY(	240	);
	OUTPUT_CATEGORY(	241	);
	OUTPUT_CATEGORY(	242	);
	OUTPUT_CATEGORY(	243	);
	OUTPUT_CATEGORY(	244	);
	OUTPUT_CATEGORY(	245	);
	OUTPUT_CATEGORY(	246	);
	OUTPUT_CATEGORY(	247	);
	OUTPUT_CATEGORY(	248	);
	OUTPUT_CATEGORY(	249	);
	OUTPUT_CATEGORY(	250	);
	OUTPUT_CATEGORY(	251	);
	OUTPUT_CATEGORY(	252	);
	OUTPUT_CATEGORY(	253	);
	OUTPUT_CATEGORY(	254	);
	OUTPUT_CATEGORY(	255	);
	OUTPUT_CATEGORY(	256	);


}