#ifndef __EFFSCRIPT_H__
#define __EFFSCRIPT_H__

#include <stdio.h>
#include <d3dx8.h>
#include <vector>

#include "CEffscriptDefine.h"
#include "X3DEffect.h"
#include "SectorEffectMap.h"
#include "Z3DGeneralChrModel.h"
#include "CLightning.h"
#include "MemoryPool.h"

using namespace std;

typedef vector<CX3DEffect *> EffList;

class RYLCreature;
	
class CEffScript 
{
public:
	
	// Pool »ç¿ë½Ã¿¡ ¸Þ¸ð¸® ÇØÁ¦°¡ Á¦´ë·Î ¾ÈµÇ°í ÀÖÀ½.. by Vincent
//	static CFixedPool ms_myPool;
//	inline void* operator new (size_t nSize)	{ return ms_myPool.ALLOC(nSize);				}
//	inline void operator delete (void* pVoid)	{ ms_myPool.FREE(pVoid, sizeof(CEffScript));	}

	// Vertex Light Àû¿ë eff 
	class CEffLight 
	{					
	public:

		char m_strEff[ESBUF_SIZE];

		CEffLight() 
		{
			memset(m_strEff,0,sizeof(char) * ESBUF_SIZE);	
		}

	};

	// °Ë±â Á¦¾î °ü·Ã Class
	class CEffWeaponLine
	{				
	public:

		char		m_strTextureName[ESBUF_SIZE];
		CTexture	*m_pLineTexture;	// Texture
		int			m_iColor[3];		// Color
		int			m_iBlendMode;		// Blend Mode

		CEffWeaponLine() 
		{
			memset(m_strTextureName,0,sizeof(char) * ESBUF_SIZE); 
			m_pLineTexture = NULL;
			m_iColor[0] = m_iColor[1] = m_iColor[2] = 255;
			m_iBlendMode = 0;

		}

		~CEffWeaponLine()
		{
			if (m_pLineTexture != NULL) 
			{
				delete m_pLineTexture;
				m_pLineTexture = NULL;				
			}
		}
	};

	// ij¸¯ÅÍ¿¡ ºÙ´Â ÀÌÆÑÆ® 
	class CEffChar 
	{					
	public:

		char m_PivotName[ESBUF_SIZE];
		D3DXVECTOR3 vecPos;				// pivot¿¡¼­ÀÇ »ó´ë ÁÂÇ¥
		D3DXQUATERNION vecQuat;			// Quaternion
		bool m_bPosUpdate;
		D3DXVECTOR3 m_vecPosBackup;		// Ãʱâ position backup
		bool m_bRotUpdate;
		D3DXQUATERNION m_RotBackup;		// Ãʱâ rotation quaternion backup
		bool m_bFirstUpdate;

		CEffChar()
		{
			memset(m_PivotName,0,sizeof(char) * ESBUF_SIZE);
			m_vecPosBackup = vecPos = D3DXVECTOR3(0.0f,0.0f,0.0f);
			m_RotBackup = vecQuat = D3DXQUATERNION(0.0f,0.0f,0.0f,1.0f);
			m_bPosUpdate = true;
			m_bRotUpdate = true;
			m_bFirstUpdate = false;
		}
	};

	// Bezier strip class
	class CEffBezier 
	{					
	public:

		int m_iAxis;					// Axis value
		char m_strTexture[ESBUF_SIZE];	// Texture Name
		float m_fUv;					// Ani Uv ´ÜÀ§
		float m_fFadeOut;				// Fade Out ´ÜÀ§
		float m_fPlaneSize;				// Plane Size

		float m_fIncreaseSpeed;			// ¾ÕÀÌ ´Ã¾î³ª´Â ¼Óµµ(ºñÀ²·Î ÇÑ´Ù)
		float m_fIncreaseAccel;			// ¾ÕÀÌ ´Ã¾î³ª´Â °¡¼Óµµ(ºñÀ²·Î ÇÑ´Ù)		
		float m_fLimitLength;			// ÃÖ°í·Î ´Ã¾î³¯ ¼ö ÀÖ´Â »çÀÌÁî 
		float m_fStartEndLength;		// ½ÃÀÛÁ¡¿¡¼­ ³¡Á¡±îÁöÀÇ ±æÀÌ
		int m_nBezierPoint;				// ÃÑ Á¦¾îÁ¡ÀÇ °¹¼ö Setting		

		float m_fBaseLength;			// óÀ½ - ³¡ Á¡ »çÀÌ¿¡¼­ÀÇ ±âÁØÁ¡ÀÇ À§Ä¡
		float m_fBaseHeight;			// ±âÁØÁ¡¿¡¼­ ³ë¸Ö ¹éÅ͸¦ ½ò¶§ÀÇ ±× ¼öÁ÷±æÀÌ
		unsigned long m_lTick;			// Tick Frame
		int m_iEndSpeed;				// µÞÁ¡(²¿¸®)ÀÇ speed
		int m_iEndAccel;				// µÞÁ¡(²¿¸®)ÀÇ accel
		int m_iUvMode;					// Uv mode

		CLightning *m_pBezierLine;		// Bezier LineÀÇ ptr
		
		CEffBezier() 
		{
			m_iAxis = 0;
			memset(m_strTexture,0,sizeof(char) * ESBUF_SIZE);
			m_fUv = 0.0f;
			m_fFadeOut = 0.1f;
			m_fIncreaseSpeed = 0.03f;
			m_fIncreaseAccel = 0.1f;
			m_fPlaneSize = 10.0f;

			m_fLimitLength = 100.0f;
			m_fStartEndLength = 0.0f;
			m_nBezierPoint = 0;

			m_fBaseLength = 0.5f;
			m_fBaseHeight = 30.0f;
			m_pBezierLine = NULL;
			m_lTick = 0;
			m_iEndSpeed = 0;
			m_iEndAccel = 0;
			m_iUvMode = 0;

		}

		~CEffBezier() 
		{
			if (m_pBezierLine != NULL) 
			{
				delete m_pBezierLine;
				m_pBezierLine = NULL;
			}
		}
	};

	// weapon effect class
	class CEffWeapon 
	{	
	public:

		int m_EffNum;
		char m_EffName[ESBUF_SIZE];

		CEffWeapon() 
		{
			m_EffNum = 0;
			memset(m_EffName,0,sizeof(char) * ESBUF_SIZE);
		}
	};

	class CEffWheel 
	{
	public:

		char m_TexName[ESBUF_SIZE];
		float m_PlaneSize;
		
		CLightning m_WheelBody;
		int m_PointNum;
		
		float m_UnitUv;
		int m_BlendMode; // blendmode	
		int m_PlaneValue; // 1ÀÚ or 10ÀÚ Ç÷£

		CEffWheel() 
		{
			memset(m_TexName,0,sizeof(char) * 256);
			m_PlaneSize = 10.0f;
			m_PointNum = 0;
			m_UnitUv = 0.0f;
			m_BlendMode = 0; // blendmode
			m_PlaneValue = 0;

		}

		~CEffWheel() {}
	};

	// Lightning °ü·Ã class
	class CEffLightn 
	{ 
	public:

		int m_LnNum;					// lightning °¹¼ö
		char m_TexName[ESBUF_SIZE];		// »ç¿ëµÇ´Â texture À̸§
		float m_PlaneSize;				// plane size
		DWORD m_Color;					// color
		float m_ShakeMin;				// shaking value min(¾ó¸¶³ª Èçµé¸±Áö)
		float m_ShakeMax;				// shaking value max(¾ó¸¶³ª Èçµé¸±Áö)
		unsigned long m_UpdateFrame;	// Èêµé¸²ÀÌ ¾÷µ¥ÀÌÆ® µÇ´Â ÇÁ·¹ÀÓ
		bool m_Follow;					// Ÿ°ÙÆÃÀ» µû¶ó°¥Áö ¾È°¥Áö
		int m_StartEffIndex;			// start eff name
		unsigned int m_StartFrame;		// start frame
		int m_EndEffIndex;				// end eff name
		unsigned int m_EndFrame;		// end frame
		CLightning *m_Lightn;
		bool m_bLightnStart;			// lightning ÀÌ ½ÃÀ۵Ǿú´ÂÁö flag
		bool m_bLightnEnd;				// lightning end flag
		int m_LPointNum;				// ºÐ±âÁ¡ °¹¼ö
		unsigned long m_StartTime;
		float m_UnitUv;
		D3DXVECTOR3 m_Pos;
		
		int m_BlendMode;				// blendmode
		float m_RandSize;				// random size
		int m_PlaneValue;				// 1ÀÚ or 10ÀÚ Ç÷£

		CEffLightn() 
		{
			m_LnNum  = 0;
			memset(m_TexName,0,sizeof(char) * ESBUF_SIZE);
			m_PlaneSize = 10.0f;
			m_Color = D3DCOLOR_ARGB(255,255,255,255);
			m_ShakeMin = 0.0f;
			m_ShakeMax = 10.0f;

			m_UpdateFrame = 30;
			m_Follow = true;
			m_StartFrame = 0;
			m_EndFrame = 0;
			m_StartEffIndex = ESEMPTY;
			m_EndEffIndex = ESEMPTY;
			m_Lightn = NULL;
			m_bLightnStart = false;
			m_bLightnEnd = false;
			m_LPointNum = 0;
			m_StartTime = 0.0;
			m_UnitUv = 0.0f;
			m_Pos.x = m_Pos.y = m_Pos.z = 0.0f;
			
			m_BlendMode = 0; // blendmode
			m_RandSize = 0.0f; // random size
			m_PlaneValue = 0;

		}

		~CEffLightn()
		{
			if (m_Lightn != NULL) 
			{
				delete[] m_Lightn;
				m_Lightn = NULL;
			}
	
		}
	};

	class CEffTextureDef 
	{
	public:

		char m_strName[ESBUF_SIZE];

		CEffTextureDef() 
		{
			memset(m_strName,0,sizeof(char) * ESBUF_SIZE);
		}
	};

	// ¿øÇü ¹æ»ç ¶óÀÌÆ®´×
	class CEffLightn2 
	{					
	public:

		int		m_iMaxLine;				// ÃÖ´ë ¶óÀÎ °¹¼ö
		float	m_fUvAniMax;			// uv ani ÃÖ´ë ´ÜÀ§	
		float	m_fRange;				// ¹üÀ§
		int		m_iBlend;				// ºí·£µå ¸ðµå
		float	m_fMinSize;				// Min Plane Size
		float	m_fMaxSize;				// Max Plane Size

		CEffLightn *m_pLightn;
		CEffTextureDef *m_pTextureName;	// Texture Name

		int m_iStartEff;
		int m_iStartFrame;
		
		int m_iEndEff;
		int m_iEndFrame;
		
		bool m_bStart;
		bool m_bEnd;
		
		D3DXVECTOR3 m_vecPos;

		unsigned long m_StartTime;

		CEffLightn2() 
		{
			m_iMaxLine = 0;
			m_fUvAniMax = 0.5f;
			m_fRange = 0.0f;
			m_pLightn = NULL;	
			m_pTextureName = NULL;
			
			m_iStartEff = ESEMPTY;
			m_iStartFrame = ESEMPTY;
		
			m_iEndEff = ESEMPTY;
			m_iEndFrame = ESEMPTY;
			m_bStart = false;
			m_bEnd = false;
			m_StartTime = 0;
			m_vecPos = D3DXVECTOR3(0.0f,0.0f,0.0f);
			m_iBlend = 0;
			m_fMinSize = 0.0f;
			m_fMaxSize = 0.0f;
		}

		~CEffLightn2() 
		{
			if (m_pLightn) 
			{
				delete[] m_pLightn;
				m_pLightn = NULL;
			}
			if (m_pTextureName) 
			{
				delete[] m_pTextureName;
				m_pTextureName = NULL;
			}
		}
	};

	// ´õ¹Ì¿¡¼­ ´õ¹Ì·ÎÀÇ ¶óÀÌÆ®´×
	class CEffLightn3 
	{					
	public:

		int		m_iEffChar;
		int		m_iMaxLine;				// ÃÖ´ë ¶óÀÎ °¹¼ö
		float	m_fUvAniMax;			// uv ani ÃÖ´ë ´ÜÀ§	
		float	m_fRange;				// ¹üÀ§
		int		m_iBlend;				// ºí·£µå ¸ðµå
		float	m_fMinSize;				// Min Plane Size
		float	m_fMaxSize;				// Max Plane Size

		CEffLightn	*m_pLightn;
		CEffChar	*m_pEffChar;
		CEffTextureDef *m_pTextureName;	// Texture Name

		bool m_bStart;
		bool m_bEnd;
		
		unsigned long m_StartTime;

		int m_iStartEff;
		int m_iStartFrame;
		int m_iEndEff;
		int m_iEndFrame;

		CEffLightn3() 
		{
			m_iMaxLine = 0;
			m_fUvAniMax = 0.5f;
			m_fRange = 0.0f;
			m_pLightn = NULL;	
			m_pTextureName = NULL;
			
			m_iStartEff = ESEMPTY;
			m_iStartFrame = ESEMPTY;
		
			m_iEndEff = ESEMPTY;
			m_iEndFrame = ESEMPTY;
			m_bStart = false;
			m_bEnd = false;
			m_StartTime = 0;
		
			m_iBlend = 0;
			m_fMinSize = 0.0f;
			m_fMaxSize = 0.0f;

			m_iEffChar = 0;
			m_pEffChar = NULL;
		}

		~CEffLightn3() 
		{
			if (m_pLightn) 
			{
				delete[] m_pLightn;
				m_pLightn = NULL;
			}
			if (m_pTextureName) 
			{
				delete[] m_pTextureName;
				m_pTextureName = NULL;
			}
			if (m_pEffChar != NULL) 
			{
				delete[] m_pEffChar;
				m_pEffChar = NULL;
			}
		}
	};

	// extension 6 :: ij¸¯ÅÍ ¹Ì²ø¸² 
	class CEffExt6
	{ 
	public:

		int m_SlideStartFrame;		// ½½¶óÀÌµå ½ÃÀÛ ÇÁ·¹ÀÓ 
		float m_SlideSpeed; 		// ¼Óµµ 
		float m_SlideAccel; 		// °¡¼Óµµ
		float m_SlideLength;		// ÃÖ´ë ¹Ì²ø¸° °Å¸® ¼¼ÆÃ
		float m_LimitSpeed;			// ÇÑ°è ½ºÇǵå
		float m_CurrentSlideLength; // ÇöÁ¦ ±îÁö ¹Ì²ø¸° °Å¸®

		CEffExt6() 
		{	
			m_SlideStartFrame = ESEMPTY;
			m_SlideSpeed = 0.0f;
			m_SlideAccel = 0.0f;
			m_SlideLength = 0.0f;
			m_LimitSpeed = 0.0f;
			m_CurrentSlideLength = 0.0f;
		}

		~CEffExt6() {}
	};

	// extension 5¿ë planeÀ» ±¸¼ºÇÏ´Â vertex class
	class CEffExt5Vertex
	{ 
	public:

		float x,y,z;
		DWORD color;
		float s,t;
		CEffExt5Vertex() 
		{
			x = y = z = 0.0f;
			color = D3DCOLOR_ARGB(255,255,255,255);
			s = t = 0.0f;
		}

		~CEffExt5Vertex() {}
	};

	// extension 5 :: °ü·Ã data °ü¸® class 
	class CEffExt5
	{ 
	public:
	
		// start, end point
		D3DXVECTOR3 m_PlaneStartPos;
		D3DXVECTOR3 m_PlaneEndPos;
		// ÀÌ ¶óÀÎÀÇ »ý¸íÀÌ ´ÙÇß´ÂÁö(¸Þ¸ð¸®¿¡¼­ »èÁ¦ µÉÁö).
		bool m_bExt5End;
		// value setting À¯¹« Ç÷¹±×
		bool m_bExt5ValueSet;
		CTexture m_PlaneTexture;
		// ½ÊÀÚ Ç÷»
		CEffExt5Vertex m_Plane[8];
		//°¢ ÄûÅüÀÌÀÇ ¾ËÆÄ
		float m_PlaneAlpha[4];
		D3DXVECTOR3 m_RandValue;
		
		unsigned long m_UpdateTime;
		//È®Àå
	
		char m_TextureName[ESBUF_SIZE];
		float m_LineSize;
		bool m_Rand;

		CEffExt5() 
		{
			m_bExt5End = false;
			m_bExt5ValueSet = false;
			m_PlaneStartPos.x = m_PlaneStartPos.y = m_PlaneStartPos.z = 0.0f;
			m_PlaneEndPos.x = m_PlaneEndPos.y = m_PlaneEndPos.z = 0.0f;	
			for(int i=0;i<4;i++) 
			{
				m_PlaneAlpha[i] = 0.7f;
			}
			m_UpdateTime = 0;
			m_RandValue.x = m_RandValue.y = m_RandValue.z  = 0.0f;
			
			memset(m_TextureName,0,sizeof(char) * ESBUF_SIZE);
			m_LineSize = 1.0f;
			m_Rand = false;	
		}

		~CEffExt5() {}
	};

	class CEffSound {
	public:
		int m_StartFrame;
		char m_Name[ESBUF_SIZE];
		//3d sound distance
		float m_Min;
		float m_Max;
		int m_Target;
		bool m_bPlay;
		CEffSound() {
			m_StartFrame = ESEMPTY;
			memset(m_Name,0,sizeof(char) * ESBUF_SIZE);
			m_bPlay = false;
			m_Min = 1.0f;
			m_Max = 10.0f;
			m_Target = ES;
		}
		~CEffSound() { }
	};

	class CEffSnap{ //snap °ü·Ã struct (¾ÆÁ÷ ±îÁö´Â ÀÌ¿ëÇÏ°í ÀÖÁö ¾Ê´Ù)
	public:
		int m_SnapStartFrame; 
		char m_PivotName[ESBUF_SIZE];
		char m_EffName[ESBUF_SIZE];
		int m_Loop;
		CEffSnap() {
			m_SnapStartFrame = ESEMPTY;
			memset(m_PivotName,0,sizeof(char) * ESBUF_SIZE);
			memset(m_EffName,0,sizeof(char) * ESBUF_SIZE);
			m_Loop = 0;
			
		}
		~CEffSnap() {}
	};

	class CEffShake {
	public:
		float m_length[3];
		float m_ShakeTime;
		float m_StartTime;
		bool m_Action;
		CEffShake() {
			m_length[0] = m_length[1] = m_length[2] = ESEMPTY;
			m_ShakeTime = 0.0f;
			m_StartTime = 0.0f;
			m_Action = false;
		}
		~CEffShake() {}
	};
	class CEffInfo { // EFf °ü·Ã data info
	public:
		bool m_bFogOff;
		bool m_LoopAction;
		char m_EffName[ESBUF_SIZE];
		float m_Scale;

		// ½ÃÀÛ ÇÁ·¹ÀÓ setting ±âº»Àº 0
		int m_MinFrame;
		// start rotation
		D3DXVECTOR3 m_StartRot;
		bool m_bStartRot;
		//fade in
		int *m_FadeInStart;
		D3DXVECTOR3 *m_FadeIn;
		color *m_FadeColor;	
		int m_FadeInNum;
		//CLight
		int *m_CLightStart;
		color *m_CLightColor;
		float *m_CLightDistance;
		DWORD *m_CLightTime;
		int m_CLightNum;
		bool *m_CLightSwitch;
		int *m_CLightTarget;

		bool *m_FadeInSwitch;
		float m_SpeedValue[3];
		float m_AccelValue[3];
		float m_StartPos[3];

		int m_LoopStart;
		int m_LoopEnd;
		int m_LoopSwitch;
		// camera shaking value
		CEffShake *m_Shake;
		int m_ShakeNum;
		// È÷Æ® À̺¥Æ® return ÇÁ·¹ÀÓ 
		int *m_HitFrame;
		int m_HitFrameNum;
		int m_HitFrameCount;
		// sound value
		CEffSound *m_Sound;
		int m_SoundNum;
		// snap value
		CEffSnap *m_Snap;
		int m_SnapNum;
		int m_SnapCount;

		// µÚ·Î ¹Ì²ø¸² value
		CEffExt6 *m_Ext6Value;
		int m_Ext6ValueNum; // ¹Ì²ø¸² num
		int m_Ext6ValueCount; // ÇöÁ¦ ±îÁö ½ÇÇàµÈ count 
		
		bool m_bRotStart;
		bool m_bLight;		// Light y/n
		CEffInfo() {
			

			m_HitFrame = NULL;
			m_HitFrameNum = 0;
			m_HitFrameCount = 0;
			//clight
	
			m_CLightSwitch = NULL;
			m_CLightStart = NULL;
			m_CLightColor = NULL;
			m_CLightDistance = NULL;
			m_CLightTime = NULL;
			m_CLightNum = 0;
			m_CLightTarget = NULL;

			m_LoopAction = false;
			m_Sound = NULL;
			m_SoundNum = 0;
			m_Shake = NULL;
			m_ShakeNum = 0;
			m_FadeInStart = NULL;
			m_FadeIn = NULL;
			m_FadeColor = NULL;	
			// rot ½ÃÀÛÇß´ÂÁö
			m_bRotStart = false;
			m_FadeInSwitch = NULL;

			memset(m_EffName,0,sizeof(char) * ESBUF_SIZE);
			m_LoopStart = ESEMPTY;
			m_LoopEnd = ESEMPTY;
			m_LoopSwitch = ESEMPTY;
			m_MinFrame = ESEMPTY;

			m_Scale = 1.0f;
			m_FadeInNum = 0;
			m_SpeedValue[0] = m_SpeedValue[1] = m_SpeedValue[2] = 0.0f;
			m_AccelValue[0] = m_AccelValue[1] = m_AccelValue[2] = 0.0f;
			m_StartPos[0] = m_StartPos[1] = m_StartPos[2] = 0.0f;

			m_StartRot.x = m_StartRot.y = m_StartRot.z = 0.0f;
			m_bStartRot = false;
			m_Ext6Value = NULL;
			m_Ext6ValueNum = 0;
			m_Ext6ValueCount = 0;
			m_Snap = NULL;
			m_SnapNum = 0;
			m_SnapCount = 0;
			m_bLight = false;
			m_bFogOff = false;
			

		}
		~CEffInfo() {
			if (m_FadeInNum >0) {
				if (m_FadeInStart != NULL) {
					delete[] m_FadeInStart;
					m_FadeInStart = NULL;
				}
				if (m_FadeIn != NULL) {
					delete[] m_FadeIn;
					m_FadeIn = NULL;
				}
				if (m_FadeColor != NULL) {
					delete[] m_FadeColor;
					m_FadeColor = NULL;
				}
				if (m_FadeInSwitch != NULL) {
					delete[] m_FadeInSwitch;
					m_FadeInSwitch = NULL;
				}
			}
			if (m_Shake) {
				delete[] m_Shake;
				m_Shake = NULL;
			}
			if (m_Sound) {
				delete[] m_Sound;
				m_Sound = NULL;
			}
			if (m_CLightStart) {
				delete[] m_CLightStart;
				m_CLightStart = NULL;
			}
			if (m_CLightColor) {
				delete[] m_CLightColor;
				m_CLightColor = NULL;
			}
			if (m_CLightDistance) {
				delete[] m_CLightDistance;
				m_CLightDistance = NULL;
			}
			if (m_CLightTime) {
				delete[] m_CLightTime;
				m_CLightTime = NULL;
			}
			if (m_CLightSwitch) {
				delete[] m_CLightSwitch;
				m_CLightSwitch = NULL;
			}
			if (m_CLightTarget) {
				delete[] m_CLightTarget;
				m_CLightTarget = NULL;
			}
			if (m_HitFrame) {
				delete[] m_HitFrame;
				m_HitFrame = NULL;
			}
			if (m_Ext6Value) {
				delete[] m_Ext6Value;
				m_Ext6Value = NULL;
			}
			if (m_Snap) {
				delete[] m_Snap;
				m_Snap = NULL;
			}
		}

	};


	class CEffPlay { // script play °ü·Ã data
	public:
		int *m_StartId;
		int m_StartIdNum;
		int m_StartCount;

		int m_StartFrameNextEff;
		float m_EndPos[3];

		int *m_MidEffId;
		int m_MidEffIdNum;
		int m_MidCount;

		float m_Speed;
		float m_Accel;
		float m_MaxSpeed;
		float m_MinSpeed;

		// effect ±ËÀû ¹æÇâ index
		int m_Direct;
		int m_MidEffNum;
		int m_StartMidNextEff;
		
		int *m_EndEffId;
		int m_EndEffIdNum;
		int m_EndCount;
		
		//CEffMidValue *m_MidValue;
		//int m_MidValueNum;

		CEffSnap *m_SnapEff;
		int m_SnapNum;
		
		CEffPlay() {
		//	m_MidValue = NULL;
		//	m_MidValueNum  =0;
			m_Speed = 0.0f;
			m_Accel = 0.0f;

			m_StartId = NULL;
			m_StartIdNum = 0;
			m_StartCount = 0;
			
			m_StartFrameNextEff = ESEMPTY;
			m_EndPos[0] = 0.0f;
			m_EndPos[1] = 0.0f;
			m_EndPos[2] = 0.0f;
			
			m_MidEffId = NULL;
			m_MidEffIdNum = 0;

			m_MidCount = 0;

			m_MaxSpeed = 0.0f;
			m_MinSpeed = 0.0f;

			m_Direct = ESEMPTY;
			m_MidEffNum = ESEMPTY;
			
			m_StartMidNextEff = ESEMPTY;

			m_EndEffId = NULL;
			m_EndEffIdNum = 0;
			m_EndCount = 0;

			m_SnapNum = 0;	
			m_SnapEff = NULL;
		}
		~CEffPlay() {
		//	if (m_MidValue)
		//		delete[] m_MidValue;
			if (m_StartId)
				delete[] m_StartId;
			if (m_MidEffId)
				delete[] m_MidEffId;
			if (m_EndEffId)
				delete[] m_EndEffId;
			if (m_SnapEff) 
				delete[] m_SnapEff;
		}
	};


	FILE *m_ScriptFile;
	char m_FileName[ESBUF_SIZE];

	EffList m_lstEff;

	//character model data
	CZ3DGeneralChrModel *m_StartChr;
	CZ3DGeneralChrModel *m_EndChr;
	float m_EndChrChest; // end chracterÀÇ Ã¼½ºÆ® ³ôÀÌ

	// ½ºÅ©¸³Æ® Á¾·ù(Zenable ų°ÍÀÎÁö ²ø°ÍÀÎÁö..)
	int m_ScriptValue;

	CEffInfo *m_EffList;

	// script ºÐ±â ó¸®
	int m_Weapone;
	int m_Sex;

	unsigned long m_MidShootFrame;
	unsigned long m_MidMoveFrame;
	float m_InterfacePos[2];
	bool m_bInterfacePos;

	CEffPlay m_EffPlayData;
	//start pos setting Çß´ÂÁö..
	bool m_StartPosSet;
	D3DXVECTOR3 m_StartPos;
	D3DXVECTOR3 m_MidPos;
	D3DXVECTOR3 m_MidUnit;
	D3DXVECTOR3 m_MidRot;
	bool m_bMidFwd;

	bool m_NotRot;

	D3DXVECTOR3 m_OldMidPos;
	// ij¸¯ÅÍ ¾Õ º¤ÅÍ
	D3DXVECTOR3 m_ChrFwd;

	float m_MidSpeed;	// ¿îµ¿ÁßÀÎ mid effectÀÇ ¼Óµµ
	
	D3DXVECTOR3 *m_EndPos;
	//interface effect projection vector
	D3DXVECTOR3 m_Projection;

	LPDIRECT3DDEVICE8 m_Device;
	matrix m_View;
	
	unsigned long m_dwTick;
	unsigned long m_dwOldTick;

	int m_EndPosNum;
	//ÇöÁ¦ ½ºÅ©¸³Æ® ÁøÇ൵ Ç¥½Ã	
	int m_ProcCount;
	// effect ¹ßµ¿ ½Ã°£(delay time)
	unsigned long m_DelayFrame;
	unsigned long m_TickFrame;

	int m_EffNum;
	int m_CurrentNum;
	//fade out value
	float m_FadeOut[3];
	bool m_FadeOutStart;
	// ´©°¡ effect¸¦ »ç¿ëÇÑ°ÇÁö
	bool m_Mine;
	// skill effect ÀÎÁö 
	bool m_bSkill;
	// sub script ÀÌ¿ë½Ã
	CEffScript *m_SubScript;
	bool m_SubFirstLoad; // sub ÀÌ¿ëÇÑ effect óÀ½ ¼öÇà½Ã ¹Ì¸® subÀÇ ¸ðµç ³»¿ë ·Îµù Çسõ´Â´Ù
	int m_SubScriptNum;
	bool m_FileLoad;
	int m_CurrentSubScript;

	int *m_NextScript;
	// Ãæµ¹½Ã true setting
	bool m_CheckCrash;
	bool m_bInterfaceSet;
	
	float m_MulPos;

	unsigned long DelayTick;
	bool DelayStart;
	int DelayFrame;
	int del_count;

	bool m_bWorldEffect;
	float m_WorldAxis[3];

	bool m_bExt1; 				// mid effect°¡ Àڱ⠻ý¸í ³¡±îÁö À¯Áö
	bool m_bExt2; 				// start effect°¡ ij¸¯ÅÍ È¸Àü¿¡ µû¶ó ³¡±îÁö À¯Áö
	bool m_bExt3; 				// extension3 aimed shot ¿ë particle À¯Áö.
	
	bool m_bExt4; 				// extension 4¸¦ À§ÇÑ flag
	CEffScript *m_Ext4Ptr;		// extension 4 setting ÀÌ Àû¿ëµÉ ½ºÅ©¸³Æ® ptr
	int m_Ext4Pivot;			// Àû¿ë pivot
	D3DXQUATERNION m_Ext4Quat;	// extension 4 ¿ë quaternion
	D3DXQUATERNION m_Ext4Object;

	bool m_bExt4InfoSet;		// extension4 data setting µÇ¾ú´ÂÁö flag
	bool m_bExt4First;

	bool m_bExt5;				// extension5 flag
	bool m_bExt5ex;				// È®Àå À¯¹«
	CEffExt5 *m_Ext5Value;
	
	bool m_bExt7; 				// extension 7¿ë flag : ³»ºÎÀûÀ¸·Î start¿Í end position change
	bool m_bExt8; 				// extension 8¿ë flag : Àû¿ëµÇ´Â ij¸¯ÅÍÀÇ scale¿¡ µû¶ó effect Å©±â Àû¿ë
	bool m_bExt9; 				// extension 9¿ë flag : snap effect °¡  ÀÌ esf °¡ ÇØÁ¦µÈ ÀÌÈÄ¿¡µµ ¸Þ¸ð¸®¿¡¼­ »èÁ¦ µÇÁö ¾Ê´Â´Ù
	bool m_bExt1Crash; 			// extension 1 »ç¿ë½Ã mid effect Ãæµ¹
	bool m_bExt3Crash; 			// extension 3 »ç¿ë½Ã mid effect Ãæµ¹

	bool m_bLightning;			// LIGHTNING flag
	
	D3DXVECTOR3 oldfwd_vec;	
	D3DXVECTOR3 fwd_vec;
	D3DXVECTOR3 pos_vec;
	bool m_bCast;				// casting effect ÀÎÁö
	bool m_bPosSet;				// pos setting ÀÌ Àû¿ëµÉÁö ¾ÈµÉÁö
	
    RYLCreature*        m_pPlayer;
    unsigned long       m_ulPlayerID;

	CEffLightn *m_Lning;		// lightning
	int m_LningNum;				// lightning number
	bool m_Chant;				// enchent or chent
	
	// ±ËÀû 
	CEffWheel *m_Wheel;
	int m_WheelNum;
	bool m_bWheel;
	bool m_bWheelStart;

	CEffWeapon *m_WeaponEff;
	int m_WeaponEffNum;
	bool m_bWeaponEff;

	bool m_bVisibility;
	
	CEffBezier *m_pBezierMid;	// Middle·Î Bezier ½ºÆ®¸³À» ÀÌ¿ë.
	bool m_bBezierMid;
	bool m_bBezierMidSet;

	CEffLightn2 *m_pLightn2; 	// Lightning 2
	bool m_bLightn2;		 	// lightning2 bool 

	CEffLightn3 *m_pLightn3; 	// Lightning 3
	bool m_bLightn3;		 	// Lightning3 bool

	int m_iLight;				// Light Àû¿ëµÇ´Â eff °¹¼ö
	CEffLight *m_pLight;

	// ½Ã°£ °³³äÀÌ µé¾î °¬À»¶§ÀÇ ½Ã°£ setting
	int m_iStartPlayTime;		// play start time
	int m_iEndPlayTime;			// play end time
	bool m_bPlayTime;			
	bool m_bVisTime;			// º¸ÀÏ ½Ã°£ÀÎÁö.
	
	bool m_bSectorCull;			// sector culling

	CEffChar *m_pEffCharacter;
	bool m_bEffCharacter;

	bool m_bFrustumCull;		// Frustum Culling À¯/¹«
	CEffWeaponLine *m_pEffWeaponLine;
	bool m_bEffWeaponLine;

	CEffScript();
	~CEffScript();
	
	bool GetScriptData(char *effect_id);
	bool GetScriptRealBinData(char *bin_name,bool vis = true);
	bool GetScriptBinData(char *bin_name,bool vis = true);
	//chent or enchent °ü·Ã bool setting
	void SetChant(bool t) {m_Chant = t;}
	bool GetChant() {return m_Chant;}

	// world effect setting 
	void SetWorldEffect(bool b) {m_bWorldEffect = b;}
	bool GetWorldEffect() { return m_bWorldEffect;}

	void GetEffNum();
	void GetSnapNum();
	void GetLnNum();
	void GetLn2Num();
	void GetLn3Num();

	void GetBinLightn2();
	
	void GetEffWheelNum();
	void GetEffWeaponNum();
	void GetEffLightNum();
	void GetEffPlayTime();
	void GetEffChar();
	void GetEffWeaponLine();
	void SetDevice(LPDIRECT3DDEVICE8 device);

	// slide character ¸¦ À§ÇÑ CCreature address setting
    void SetPlayer( RYLCreature* pCreature, unsigned long ulCreatureID )
    {
        if ( pCreature )
        {
            m_pPlayer   = pCreature;
            m_ulPlayerID= ulCreatureID;
        }

        for( int i = 0 ; i < m_SubScriptNum ; ++i ) 
        {
			if ( m_SubScript )
				m_SubScript[ i ].SetPlayer( pCreature, m_ulPlayerID );
		}
    }

	// ij¸¯ÅÍ ¸ðµ¨ ¼¼ÆÃ
	void SetChr(CZ3DGeneralChrModel *s,CZ3DGeneralChrModel *e);
	
	// chracter fwd vector setting(use start effect)
	void SetChrFwd(float x,float y,float z);

	// interface or normal script
	void SetScriptValue(int n); 

	void SetCast(bool t);
	void SetPosSet(bool t) {m_bPosSet = t;}

	void SetCrash(bool t) {m_CheckCrash = t;}
	bool GetCrash() {return m_CheckCrash;}
	void SetInterfaceSet(bool b) ;
	void GetStartEndNum();
	void GetSubNum();
	void GetExt5ex(char *);
	void GetSubData(char *);
	void GetBinSubData(int index,char *filename);
	void GetEffList(char *);
	void GetEffLoop(char *);
	void GetEffPlay(char *);
	void GetEffSnap(char *);
	void GetFadeOut(char *);
	void GetFadeIn(char *);
	void GetCLight(char *);
	void GetCameraShake(char *);
	void GetSound(char *);
	void GetSlide(char *);
	void GetLightn(char *);
	void GetLightn2(char *);
	void GetLightn3(char *);

	void GetEffWheel(char *);
	void GetEffWeapon(char *);
	void GetEffBezier(char *);
	void GetEffLight(char *);

	void GetHit(char *);

	D3DXQUATERNION GetExt4Quat();
	void WriteConvertFile(char *name);
	//void SetWheelPoint(int index,float x,float y,float z);
	// ´©±¸ÀÇ ½ºÅ³ÀÎÁö s : ¼ºº° w : ¹«±â Á¾·ù
	void SetSkillInfo(int s,int w);
	void SetAllLoopOff();
	
	void SetStartPos(D3DXVECTOR3 );
	void SetStartPos(float x,float y,float z);
	
	void SetMine(bool m);
	bool GetMine() {return m_Mine;}
	// skill effect À϶§ setting 
	void SetBSkill(bool m) {m_bSkill = m;}
	bool GetBSkill() { return m_bSkill;}
	void SetRot(D3DXVECTOR3 before,D3DXVECTOR3 now,D3DXVECTOR3 &target);

	void SetMidPos(D3DXVECTOR3 pos) {m_OldMidPos = m_MidPos; m_MidPos = pos;}
	void SetMidPos(float x,float y,float z){m_OldMidPos = m_MidPos;m_MidPos.x = x; m_MidPos.y = y;m_MidPos.z = z;}
	void SetOldMidPos(float x,float y,float z) {m_OldMidPos.x = x;m_OldMidPos.y =y; m_OldMidPos.z = z;}
	void SetMidSpeed(float s) {m_MidSpeed = s;}
	
	void SetEndPos(D3DXVECTOR3 *end,int num);
	void SetEndPos(float ,float ,float );
	void SetEffectRot(float x,float y,float z);
	// Ãʱâ À§Ä¡¿¡ °öÇÒ °ª ¼¼ÆÃ
	void SetMulPosition(float s){m_MulPos = s;}


	void SetTickFrame(int tick) {m_TickFrame = tick; }
	void PushEff();// script¾È¿¡ Á¸ÀçÇÏ´Â effect load
	void PlayFadeIn(int index,int j); //fadein play func
	void PlayCLight(int index,int j);
	void PlayEffSound(int index,int j,float x,float y,float z,float mind,float maxd); //sound play func
	void PlayEffSound(int index,int j);
	void StopEffSound(int index,int j,float x,float y,float z,float mind,float maxd);
	void PlaySlide(int index,int j);
	void PlaySnap(int index,int j);
	
	void PlayTime();				// Play Start End Time


	void PlayLning(int index,int obj_index,float currentframe,D3DXVECTOR3 vecChar);
	void PlayLning2(int index,int obj_index,float currentframe,D3DXVECTOR3 vecChar);
	void PlayLning3(int index,int obj_index,float currentframe,D3DXVECTOR3 vecChar);

	void RenderLightn();
	void RenderLightn2();
	void RenderLightn3();

	void UpdateLning(int index,D3DXVECTOR3 vecChar);
	void UpdateLning2(D3DXVECTOR3 vecChar);
	void UpdateLning3(D3DXVECTOR3 vecChar);

	void PlayWheel();
	void RenderWheel();
	void UpdateWheel(float x = 0.0f,float y = 0.0f,float z = 0.0f,float nx = 0.0f,float ny = 0.0f,float nz = 0.0f,int value = 0);
	
	void PlayWeaponEff();
	void DeleteWeaponEff();

	void PlayWeaponLine();
	void DeleteWeaponLine();
	
	int ProcessEffect(bool bWeatherEffect = true);
	void Render();
	void RenderExt5();

	void SetExt4Ptr(CEffScript *);
	void SetExt4Info(int pivotnum,D3DXQUATERNION rot);
	void SetExt4SelfInfo(D3DXQUATERNION rot); // ÀÚ½ÅÀÇ Á¤º¸ ¼¼ÆÃ
	void SetExt4Rot(D3DXQUATERNION rot);
	
	void SetVisibility(bool t);
	void SetLight();		// Vertex Light Setting	
	// Bezier Mid's Func
	void SetInitBezier(float startx,float starty,float startz,float endx,float endy,float endz);
	bool GetSectorCull() {return m_bSectorCull;}
	void SetSectorCull(bool b) {m_bSectorCull = b;}

	void SetScale(float fScale);
	void Clone(CEffScript *Clone);
	void GetSubClone(int index,CEffScript *Clone,char *filename);

	// ±ËÀû strip
	//void RenderStrip(int index);

};


class CEffCacheObj {
public:
	std::vector<CEffScript *>	m_lstDatas;
	int							m_iDatasNum;
	CEffCacheObj() : m_iDatasNum(0)
	{
		m_lstDatas.clear();
	}
	CEffCacheObj(CEffScript *pObj)  : m_iDatasNum(0)
	{
		m_lstDatas.clear();
		m_lstDatas.push_back(pObj);
		m_iDatasNum++;
	}
	void Add_Back(CEffScript *pObj)
	{
		m_lstDatas.push_back(pObj);
		m_iDatasNum++;
	}
	~CEffCacheObj() {
		if (m_iDatasNum > 0)
		{
			for(int i=0;i < m_iDatasNum; i++) 
			{
				if (m_lstDatas[i]) 
				{
					if (m_lstDatas[i])
					{
						delete m_lstDatas[i];
					}
					m_lstDatas[i] = NULL;

				}
			}
		}
		m_iDatasNum =  0;
		m_lstDatas.clear();
	}

		
			
};

typedef std::map<unsigned long , CEffCacheObj *> EFFCACHETABLE;
typedef EFFCACHETABLE::value_type EFFCACHETABLEOBJ;
typedef EFFCACHETABLE::iterator EFFCACHEITER;
/* *********************************************************************  

* CBaseCacheMgr

* ÆÄÀÏ : BaseCacheMgr.h 
* ±â´É : Caldron¿£Áø ³»ºÎ¿¡¼­ »ç¿ëµÇ´Â ¸ðµç CacheMgrµéÀÇ ¾î¹Ì class
* history : 
	2004.01.16 wizardbug

********************************************************************** */  
const int DEFAULT_EFFMAXCACHENUM = 100;
class CEffectCacheMgr
{
protected:
	
	unsigned long GetHashID(const char *strFileName)
	{
		unsigned long ulHashId = 0;

		int iLength = (int)strlen(strFileName);

		for(int i=0;i < iLength; i++) {
			ulHashId += (( i + 1) * strFileName[i]);
		}	
		return ulHashId;


	}

	EFFCACHETABLE m_CacheTable;
	int	m_iCachesNum;
	bool m_bFirst;
	bool m_bInitLoadScript;


public:
	CEffectCacheMgr(void) : m_iCachesNum(0),m_bFirst(true),m_bInitLoadScript(false)
	{
		m_CacheTable.clear();
	}
	~CEffectCacheMgr(void)
	{
		if (m_iCachesNum > 0) 
		{
			for(EFFCACHEITER Itr = m_CacheTable.begin(); Itr != m_CacheTable.end();) 
			{
				if (Itr->second != NULL) 
				{
					if (Itr->second)
					{
					
						delete (Itr->second);
					}
					Itr->second = NULL;

				}
				
				Itr++;
			}
			m_CacheTable.clear();
			m_iCachesNum = 0;

		}

	}
	CEffScript *GetData(const char *strFileName);
	
	CEffScript *LoadData(const char *strFileName);
	void InitLoad();


};

#endif