#pragma once

#include <mmo/ArType.h>
#include "SkillBase.h"
#include "ContentStruct.h"
#include "GameDefine.h"
#include "SGameAniType.h"

const static int strSize = 3072;

inline char* allocString( const char* p )
{
	return (char*)memcpy( new char[ strlen(p)+1 ], p, strlen(p)+1 );
}

/// 게임 컨텐츠 DB파일 헤더
#define STR_DATE_BUFFER 128
struct GAME_DB
{
	GAME_DB()
	{
		memset( szDate, 0, sizeof(szDate) );
		nCount = 0;
	}

	char szDate[STR_DATE_BUFFER]; ///< 생성 날짜
	int  nCount;      ///< 갯수
};

struct _EXP_TABLE
{
	__int64 exp;
	__int64 jp[4];
};

struct _SUMMON_EXP_TABLE
{
	__int64 exp_normal;
	__int64 exp_growth;
	__int64 exp_evolve;
};

struct _STRING_TABLE
{
	int		nID;
	int		nGroupID;
	char*	szKey;
	unsigned int nKeySize;
	char*	szDesc;
	unsigned int nDescSize;

	_STRING_TABLE() : nID( -1 )
					, nGroupID( -1 )
					, szKey( NULL )
					, nKeySize( 0 )
					, szDesc( NULL )
					, nDescSize( 0 )
	{}

	~_STRING_TABLE()
	{
		delete [] szKey;
		delete [] szDesc;
	}

	void	SetStringKey( const char* pszKey, unsigned int _keysize )
	{
		if( pszKey != NULL && _keysize > 0 )
		{
			nKeySize = _keysize;
			szKey = new char[_keysize];
			strcpy( szKey, pszKey );
		}
	}
	void	SetStringDesc( const char* pszDesc, unsigned int _descsize )
	{
		if( pszDesc != NULL && _descsize > 0 )
		{
			nDescSize = _descsize;
			szDesc = new char[_descsize];
			strcpy( szDesc, pszDesc );
		}
	}

};

struct _STRING_TABLE_INFO
{
	_STRING_TABLE_INFO()
	{
		// pStrKey  = NULL;
		pStrDesc = NULL;
	}
	~_STRING_TABLE_INFO()
	{
		// if(pStrKey ) { delete [] pStrKey;  pStrKey  = NULL; } 
		if(pStrDesc) { delete [] pStrDesc; pStrDesc = NULL; }
	}

	void operator=( const _STRING_TABLE_INFO & rh )
	{
		if(pStrDesc) { delete [] pStrDesc; pStrDesc = NULL; }
		nID = rh.nID;
		nGroupID = rh.nGroupID;
		pStrDesc = allocString( rh.pStrDesc );
	}

	void SetInfo( const struct _STRING_TABLE * pStringTable )
	{
		nID			= pStringTable->nID;
		nGroupID	=	pStringTable->nGroupID;
		// pStrKey  = allocString( pStringTable->szKey );
		pStrDesc	= allocString( pStringTable->szDesc );
	}

	void SetInfo( const int _nID, const int _nGroupID, const char *_szString )
	{
		nID			= _nID;
		nGroupID	= _nGroupID;
		pStrDesc	= allocString( _szString );
	}

	int			nID;
	int			nGroupID;
 // char *		pStrKey;
	char *		pStrDesc;
};
#ifdef _RDBGENTEST
#pragma pack(push,1)
#endif
struct StateInfoEx : public StateInfo
{
	StateInfoEx()
	{
		nIcon_id       = 0;
		memset(icon_file_name, 0, sizeof(icon_file_name));
		fx_id          = 0;
		pos_id         = 0;

		cast_fx_id     = 0;
		cast_fx_pos_id = 0;

		cast_skill_id  = 0;

		hit_fx_id      = 0;
		hit_fx_pos_id  = 0;

		special_output_timing_id = 0;
		special_output_fx_id     = 0;
		special_output_fx_pos_id = 0;
		special_output_fx_delay  = 0;
	}

	// sonador 10.4.1	스킬 툴팁 리뉴얼
	float GetBasicFx_AmpDamage( int stateLevel )
	{
		return amplify_base + stateLevel * amplify_per_skl;
	}

	int GetBasicFx_AddDamage( int stateLevel )
	{
		return add_damage_base + stateLevel * add_damage_per_skl;
	}

	int		nIcon_id;		///< 지속효과 아이콘 ID
	char	icon_file_name[256];

	int		fx_id;          ///< 기본 FX
	int		pos_id;         ///< 기본 FX 위치

	int		cast_fx_id;     ///< 지속중 특정 스킬 사용시 동반 출력 FX ID
	int		cast_fx_pos_id; ///< 지속중 특정 스킬 사용시 동반 출력 FX 위치

	int		cast_skill_id;	

	int		hit_fx_id;      ///< 지속중 특정 스킬 히트시 동반 출력 FX ID
	int		hit_fx_pos_id;  ///< 지속중 특정 스킬 히트시 동반 출력 FX 위치

	int		special_output_timing_id; ///< 지속중 특정상황시에만 동반출력될 FX 시점
	int		special_output_fx_id;     ///< 지속중 특정상황시에만 동반출력될 FX ID
	int		special_output_fx_pos_id; ///< 지속중 특정상황시에만 동반출력될 FX 위치
	int		special_output_fx_delay;  ///< 지속중 특정상황시에만 동반출력될 FX 딜레이

	int		state_fx_id;			  ///< INT				NOT NULL		--	43
	int		state_fx_pos_id;		  ///< INT				NOT NULL		--	44
};
#ifdef _RDBGENTEST
#pragma pack(pop)
#endif

#ifdef _RDBGENTEST
#pragma pack(push,1)
#endif
/// 화일 Save/Load 용
struct ItemBaseEx : public ItemBase
{
	ItemBaseEx()
	{
		model_type_dem	=	0;
		model_type_asm	=	0;
		model_type_gam	=	0;
		model_type_def	=	0;
		model_type_asf	=	0;
		model_type_gaf	=	0;

		deco_model_change	=	false;
		unknow		=	0;
		
		model00		=	0;
		model01		=	0;
		model02		=	0;
		model03		=	0;
		model04		=	0;
		model05		=	0;
		model06		=	0;
		model07		=	0;
		model08		=	0;
		model09		=	0;
		model10		=	0;
		model11		=	0;
		model12		=	0;
		model13		=	0;
		model14		=	0;
		model15		=	0;
		model16		=	0;
		model17		=	0;
		texture_filename	=	0;

		drop_model		=	0;
		
		icon_id			=	0;
		icon_file_name	=	0;

		nToolTipID = 690000075; /*존재하지 않는 아이템*/
	}

	void SetInfo(int nSid, std::vector< ItemEnhanceEffectBase > * pEnhanceBase )
	{
		ItemEnhanceEffectBase enhanceBase;
		for( int i(0); i < 2; i++)
		{
			memset(&enhanceBase, 0, sizeof(enhanceBase));

			enhanceBase.sid		= nSid;
			enhanceBase.sub_id	= i + 1;
			enhanceBase.effect_id	= effect_id[i];

			for (int v(0); v < 25; v++)
			{
				if (v >= 0 && v < 4)
					enhanceBase.value[v] = value[i][0];
				else if (v >= 4 && v < 8)
					enhanceBase.value[v] = value[i][1];
				else if (v >= 8 && v < 12)
					enhanceBase.value[v] = value[i][2];
				else if (v >= 12 && v < 16)
					enhanceBase.value[v] = value[i][3];
				else if (v >= 16 && v < 20)
					enhanceBase.value[v] = value[i][3];
				else
					enhanceBase.value[v] = value[i][v - 15];
			}
			
			pEnhanceBase->push_back( enhanceBase );
		}
	}

	//투구 관련
	char	model_type_def;
	char	model_type_asf;
	char	model_type_gaf;
	char	unknow;
	char	model_type_dem;
	char	model_type_asm;
	char	model_type_gam;

	bool	deco_model_change;
	char	unknow2[8];

	short	model00;
	short	model01;
	short	model02;
	short	model03;
	short	model04;
	short	model05;
	short	model06;
	short	model07;
	short	model08;
	short	model09;
	short	model10;
	short	model11;
	short	model12;
	short	model13;
	short	model14;
	short	model15;
	short	model16;
	short	model17;
	// 텍스처 컬럼 추가 kappamind, 09.09.11
	short	texture_filename;

	short	drop_model;
	short	icon_id;
	short	icon_file_name;
	int     nToolTipID;

	//gmpbigsun( 20130916 ) : 아이템분류값
	int		nCategory_Bitset;

	short	effect_id[2];
	float	value[2][10];
};
#ifdef _RDBGENTEST
#pragma pack(pop)
#endif

#ifdef _RDBGENTEST
#pragma pack( push, 1 )
#endif
/// 게임에서 사용
struct ItemBaseEx_info : public ItemBase
{
	ItemBaseEx_info()
	:	pModel00( "" ) 
	,	pModel01( "" ) 
	,	pModel02( "" )
	,	pModel03( "" )
	,	pModel04( "" )
	,	pModel05( "" ) 
	,	pModel06( "" ) 
	,	pModel07( "" ) 
	,	pModel08( "" ) 
	,	pModel09( "" ) 
	,	pModel10( "" ) 
	,	pModel11( "" ) 
	,	pModel12( "" ) 
	,	pModel13( "" ) 
	,	pModel14( "" ) 
	,	pModel15( "" ) 
	,	pModel16( "" ) 
	,	pModel17( "" ) 
	,	pTexture_filename( "" )
	,	pDrop_model( "" )
	,	pScript_text( "" )
	,	pIcon_name( "" )
	,	deco_model_change( false )
	{
	}
	
	~ItemBaseEx_info()
	{
		if( pModel00    ) { delete [] pModel00   ; pModel00    = NULL; }
		if( pModel01    ) { delete [] pModel01   ; pModel01    = NULL; }
		if( pModel02    ) { delete [] pModel02   ; pModel02    = NULL; }
		if( pModel03    ) { delete [] pModel03   ; pModel03    = NULL; }
		if( pModel04    ) { delete [] pModel04   ; pModel04    = NULL; }
		if( pModel05    ) { delete [] pModel05   ; pModel05    = NULL; }
		if( pModel06    ) { delete [] pModel06   ; pModel06    = NULL; } 
		if( pModel07    ) { delete [] pModel07   ; pModel07    = NULL; } 
		if( pModel08    ) { delete [] pModel08   ; pModel08    = NULL; } 
		if( pModel09    ) { delete [] pModel09   ; pModel09    = NULL; } 
		if( pModel10    ) { delete [] pModel10   ; pModel10    = NULL; } 
		if( pModel11    ) { delete [] pModel11   ; pModel11    = NULL; } 
		if( pModel12    ) { delete [] pModel12   ; pModel12    = NULL; } 
		if( pModel13    ) { delete [] pModel13   ; pModel13    = NULL; } 
		if( pModel14    ) { delete [] pModel14   ; pModel14    = NULL; } 
		if( pModel15    ) { delete [] pModel15   ; pModel15    = NULL; } 
		if( pModel16    ) { delete [] pModel16   ; pModel16    = NULL; } 
		if( pModel17    ) { delete [] pModel17   ; pModel17    = NULL; } 

		if( pTexture_filename    ) { delete [] pTexture_filename   ; pTexture_filename    = NULL; } 

		if( pDrop_model ) { delete [] pDrop_model ; pDrop_model  = NULL; }
		if( pScript_text) { delete [] pScript_text; pScript_text = NULL; }
		if( pIcon_name   ) { delete [] pIcon_name ; pIcon_name   = NULL; }
	}

	void SetInfo( ItemBaseEx * pItemBaseEx )
	{
		nCode      				= pItemBaseEx->nCode		;		///< 아이템 코드
		nNameId    				= pItemBaseEx->nNameId    	;	///< 이름
		nType      				= pItemBaseEx->nType      	;	///< 아이템 타입
		nGroup     				= pItemBaseEx->nGroup     	;	///< 그룹 ID
		nClass     				= pItemBaseEx->nClass     	;	///< 계열
		set_id					= pItemBaseEx->set_id	  	;	///< 소속 세트 아이디 // #2.1.2.6.1
		set_part_flag			= pItemBaseEx->set_part_flag;	// 
		nGrade					= pItemBaseEx->nGrade		;	///< 등급
		nRank      				= pItemBaseEx->nRank      	;	///< 랭크
		nMinLevel  				= pItemBaseEx->nMinLevel  	;
		nMaxLevel  				= pItemBaseEx->nMaxLevel  	;
		nRange     				= pItemBaseEx->nRange     	;	///< 사정거리
		fWeight    				= pItemBaseEx->fWeight    	;	///< 무게
		nPrice     				= pItemBaseEx->nPrice     	;	///< 기준가격
		nHuntaholicPoint		= pItemBaseEx->nHuntaholicPoint;///< #2.1.2.11.1 -- 상점 판매가 - 헌터홀릭 포인트
		nEthereal_durability	= pItemBaseEx->nEthereal_durability;	// 에테리얼 내구도
		nEndurance 				= pItemBaseEx->nEndurance 	;	///< 내구성
		WearType   				= pItemBaseEx->WearType   	;
		nLimit     				= pItemBaseEx->nLimit     	;	///< 사용제한
		Flag       				= pItemBaseEx->Flag       	;
		socket	   				= pItemBaseEx->socket     	;
		status_flag				= pItemBaseEx->status_flag	;	///< sonador 3.9.5	상점 판매 크리처 봉인 카드 켑션 수정
		job_depth				= pItemBaseEx->job_depth	;	/// 2011.03.30 - prodongi
		nMaterial   			= pItemBaseEx->nMaterial  	;
		nSummonId   			= pItemBaseEx->nSummonId  	;
		nThrowRange 			= pItemBaseEx->nThrowRange	;
		level					= pItemBaseEx->level		;
		enhance					= pItemBaseEx->enhance		;	///< sfreer 상점 및 카트에 담긴 아이템 비정상적인 수치출력관련 버그 수정 2009.03.05
		nEffectId				= pItemBaseEx->nEffectId	;	///< 아이템 특수 성능, kappamind

		
		for( int i(0); MAX_OPTION_NUMBER>i; i++ )
		{
			nBaseType[i] = pItemBaseEx->nBaseType[i];
			dBaseVar1[i] = pItemBaseEx->dBaseVar1[i];
			dBaseVar2[i] = pItemBaseEx->dBaseVar2[i];

			nOptType[i]  = pItemBaseEx->nOptType[i] ;
			dOptVar1[i]  = pItemBaseEx->dOptVar1[i] ;
			dOptVar2[i]  = pItemBaseEx->dOptVar2[i] ;
		}

		nEnhanceID	= pItemBaseEx->nEnhanceID;

		nSkillID    = pItemBaseEx->nSkillID;

		nStateCode  = pItemBaseEx->nStateCode ;
		nStateLevel = pItemBaseEx->nStateLevel;
		nStateTime  = pItemBaseEx->nStateTime ;
		nCoolTime   = pItemBaseEx->nCoolTime  ;

		nCoolTimeGroup = pItemBaseEx->nCoolTimeGroup;

		available_time = pItemBaseEx->available_time;
		decrease_type = pItemBaseEx->decrease_type;

		icon_id    = pItemBaseEx->icon_id;
		nToolTipID = pItemBaseEx->nToolTipID;

		model_type_dem = pItemBaseEx->model_type_dem;
		model_type_def = pItemBaseEx->model_type_def;
		model_type_asm = pItemBaseEx->model_type_asm;
		model_type_asf = pItemBaseEx->model_type_asf;
		model_type_gam = pItemBaseEx->model_type_gam;
		model_type_gaf = pItemBaseEx->model_type_gaf;

		deco_model_change	=	pItemBaseEx->deco_model_change;

		nCategory_Bitset = pItemBaseEx->nCategory_Bitset;

	}

	enum MODEL_FLAG
	{
		NONE_FLAG = 0,
		HAIR_FLAG = 1 << 0,
		FACE_FLAG = 1 << 1, // sonador #2.1.22
		EARRING_FLAG  = 1 << 2, // 2010.08.16 - prodongi
	};

	//투구 관련
	int		model_type_dem;
	int		model_type_def;
	int		model_type_asm;
	int		model_type_asf;
	int		model_type_gam;
	int		model_type_gaf;

	bool	deco_model_change;

	char *	pModel00;
	char *	pModel01;
	char *	pModel02;
	char *	pModel03;
	char *	pModel04;
	char *	pModel05;
	char *	pModel06;
	char *	pModel07;
	char *	pModel08;
	char *	pModel09;
	char *	pModel10;
	char *	pModel11;
	char *	pModel12;
	char *	pModel13;
	char *	pModel14;
	char *	pModel15;
	char *	pModel16;
	char *	pModel17;

// 텍스처 컬럼 추가 kappamind, 09.09.11
	char *	pTexture_filename;

	char *	pDrop_model;
	int     icon_id;
	char *	pIcon_name;
	char *	pScript_text;
	int     nToolTipID;

	int nCategory_Bitset;
};
#ifdef _RDBGENTEST
#pragma pack(pop)
#endif

#ifdef _RDBGENTEST
#pragma pack( push, 1 )
#endif
struct JobInfoEx : public JobInfo
{
	JobInfoEx()
	{
		job_icon = 0;
		memset( icon_file_name, 0, sizeof(icon_file_name) );
	};

	int				job_icon;
	char			icon_file_name[256];
};
#ifdef _RDBGENTEST
#pragma pack(pop)
#endif

#pragma pack( push, 1 )

struct SkillBaseEx : public SkillBase
{
	SkillBaseEx()
	{
		nTooltip_id = 0;

		nIcon_id    = 0;
		memset( icon_file_name, 0, sizeof(icon_file_name));

		is_projectile				=	0;
		projectile_speed			=	0.f;
		projectile_acceleration		=	0.f;
	}

	int			GetToolTipID() const		{ return nTooltip_id; }
	int			GetIconID() const			{ return nIcon_id; }
	const char* GetIconName() const			{ return icon_file_name; }

	int		nTooltip_id;	///< 툴팁 ID

	int		nIcon_id;		///< 스킬 아이콘 ID
	char	icon_file_name[256];

	char	is_projectile;
	float	projectile_speed;
	float	projectile_acceleration;

	int GetRealSize()
	{
		void * vp = &nTooltip_id;
		return ( sizeof( SkillBaseEx ) - ( (int)vp - (int)this ) );	
	}

	int GetOffset()
	{		
		return ( (long long)(SkillBaseEx *)1 - (long long)(SkillBase *)(SkillBaseEx *)1 );
	}
};

#pragma pack(pop)


struct SkillBaseEx_info : public SkillBase
{
	SkillBaseEx_info( const SkillBaseEx & base ) : SkillBase( base )
	{
		nTooltip_id = base.nTooltip_id;

		nIcon_id    = base.nIcon_id;
		memset( icon_file_name, 0, sizeof(icon_file_name));

		is_projectile			=	base.is_projectile;
		projectile_speed		=	base.projectile_speed;
		projectile_acceleration	=	base.projectile_acceleration;
		
	}

	int			GetToolTipID() const		{ return nTooltip_id; }
	int			GetIconID() const			{ return nIcon_id; }
	const char* GetIconName() const			{ return icon_file_name; }

	int		nTooltip_id;	///< 툴팁 ID

	int		nIcon_id;		///< 스킬 아이콘 ID
	char	icon_file_name[256];

	char	is_projectile;
	float	projectile_speed;
	float	projectile_acceleration;

};
#ifdef _RDBGENTEST
#pragma pack(push,1)
#endif
struct _SKILL_FX 
{
	enum
	{
		SKILLTYPE_NOACT            = 0,		///< 0 : 노액션스킬 (캐스팅,시전모션 없고 시전 FX처리만 존재함)
		SKILLTYPE_MAGIC            = 1,		///< 1 : 마법류 -> 자동 캐스팅 모션 & 이펙트 처리 (하드코딩)
		SKILLTYPE_INSTANT          = 2,		///< 2 : 즉시시전스킬 (바로시전)
		SKILLTYPE_INSTANT_CONTINUE = 3,		///< 3 : 즉시시전 연속모션 스킬 (연출데이터에서 모션처리 정보가 등록됨)
		SKILLTYPE_CHARGE           = 4,		///< 4 : 차지형스킬 (캐스팅시작->캐스팅진행->시전) 캐스팅시작모션은 생략가능
		SKILLTYPE_CHARGE_CONTINUE  = 5,		///< 5 : 차지형 연속모션 스킬 (연출데이터에서 모션처리 정보가 등록됨)
	};

	_SKILL_FX()
	{
		nID								=	0;
		szElemental						=	NULL;
		szType							=	NULL;
		szDeal_Damage					=	NULL;
		szHas_Target					=	NULL;
		szCorpse_Target					=	NULL;
		szIs_Toggle						=	NULL;
		casting_time					=	0.0f;
		szIs_Creature_Skill				=	NULL;

		nStage_Type_Id					=	0;
		nCasting_Type_Id				=	0;
		nCasting_Start_Motion_Id		=	0;
		nCasting_Middle_Motion_Id		=	0;
		nCasting_Fx_Set_Id				=	0;
		nFire_Motion_Id					=	0;	
		nFire_Fx_Set_Id					=	0;

		for( int i(0); 20>i; i++ ) 
			fStage_Data[i]	=	0;

		nSub_Stage_On_Hit_Id			=   0;
		nSub_Stage_On_Hit_Continuous	=   0;
		nSub_Hit_Fx_OutPut_Delay		=   0;	

		nHit_Fx_Set_Id					=   0;
		nHit_Fx_Set_Position_Id			=   0;

		nFire_Fx_OutPut_Delay			=   0;
		nSub_Fire_Fx_Set_Id				=   0;
		nSub_Fire_Fx_Position			=   0;
	}

	int nID;                        ///< ID
	char szElemental;				///< 엔레멘탈(속성)( 무속성 0, 화속성 1, 수속성 2, 풍속성 3, 토속성 4, 명속성 5, 암속성 6 )
	char szType;					///< 타입( 0:전투기술, 1:마법 )
	char szDeal_Damage;				///< 피해여부( 0:대상에게 이로움, 1:대상에게 해로움 )
	char szHas_Target;				///< 셀프/타겟( 0:셀프, 1:타겟 )
	char szCorpse_Target;			///< 시체대상( 0:대상이 시체가 아닐때만 사용가능,	1:대상이 시체일때만 사용가능 )
	char szIs_Toggle;				///< 토글형(0:일반, 1:토글)
	float casting_time;				///< DECIMAL( 10, 3 )				NOT NULL ,	--				08
	char szIs_Creature_Skill;		///< 크리처 스킬(0:아바타, 1:크리처, 2:몬스터)

	int  nStage_Type_Id;			///< 연출 유형

	/**	캐스팅 타입
		0 : 노액션스킬 (캐스팅,시전모션 없고 시전 FX처리만 존재함)
		1 : 마법류 -> 자동 캐스팅 모션 & 이펙트 처리 (하드코딩)
		2 : 즉시시전스킬 (바로시전)
		3 : 즉시시전 연속모션 스킬 (연출데이터에서 모션처리 정보가 등록됨)
		4 : 차지형스킬 (캐스팅시작->캐스팅진행->시전) 캐스팅시작모션은 생략가능
		5 : 차지형 연속모션 스킬 (연출데이터에서 모션처리 정보가 등록됨)
	*/
	int  nCasting_Type_Id;          
	int  nCasting_Start_Motion_Id;  ///< 캐스팅 시작 모션 셋트
	int  nCasting_Middle_Motion_Id; ///< 캐스팅 진행 모션 셋트
	int  nCasting_Fx_Set_Id;        ///< 캐스팅 FX 셋트
	int  nFire_Motion_Id;	        ///< 시전 모션 셋트 
	int  nFire_Fx_Set_Id;           ///< 시전 FX 셋트

	float	fStage_Data[20];            ///< 연출 데이타 01

	int  nSub_Stage_On_Hit_Id;			///< 히트시 부가연출
	int  nSub_Stage_On_Hit_Continuous;  ///< 연타 히트
	int  nSub_Hit_Fx_OutPut_Delay;	    ///< 히트시 부가 발동FX 출력 딜레이
 
	int  nHit_Fx_Set_Id;                ///< 히트FX 셋트
	int  nHit_Fx_Set_Position_Id;       ///< 히트FX 위치
	int  nFire_Fx_OutPut_Delay;         ///< 히트시 발동 FX 출력 딜레이

	int  nSub_Fire_Fx_Set_Id;           ///< 부가발동FX 셋트
	int  nSub_Fire_Fx_Position;         ///< 부가발동FX 위치
};
#ifdef _RDBGENTEST
#pragma pack(pop)
#endif
struct _FIELD_TYPE_MATERIAL
{
	_FIELD_TYPE_MATERIAL()
	{
		memset( szTexture_File_Name, 0, sizeof( szTexture_File_Name ) );
		nMaterial		=	0;
	}

	char	szTexture_File_Name[256];
	int		nMaterial;
};