#pragma	 once
//
#include "K3DTypes.h"
#include <Windows.h>
#include "SGameObject.h"
#include "SkillBase.h"

//#include <string>

////////////////////////////////////////////////////////////////////////////
/// SGameAction
class SGameAction : public SGameObject
{
public:
	enum ENUM_STEP
	{
		STEP_00, STEP_01, STEP_02, STEP_03, STEP_04, 
		STEP_05, STEP_06, STEP_07, STEP_08, STEP_09, 
		STEP_10,
		STEP_MAX,
	};

	SGameAction();
	virtual ~SGameAction();

	virtual bool IsEnd()			 { return m_bIsEnd;   }
	void		SetEnd( bool bIsEnd ){ m_bIsEnd = bIsEnd; }
	int			GetStep()			 { return m_nStep;    }

	bool							CheckTime( DWORD time )
	{ 
		if( m_dwFxTimeOver == 0 )
			m_dwFxTimeOver	=	time;

		if( time - m_dwFxTimeOver < 30000 )
			return false;

		return true;
	};

	virtual bool Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	virtual bool Render( unsigned long uRenderBitVector, class KViewportObject** ppViewportList, int nViewportCount );
	virtual void InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx ){};
	virtual void InitFx( struct SMSG_ATTACK* pMsg ){};
	virtual void SetResultIndex( int iResultIndex ){};
	void		 DefProcess();

	bool		 CheckAttacker();
	bool		 CheckTarget();

	virtual void SetMultiAttackInfo( bool bMultiAttack ) { m_bMultiAttack = bMultiAttack; }

	void		(*think)(int *self);
protected:
	bool	(SGameAction::*Function_Step[STEP_MAX])();
	virtual	bool Step01();
	virtual	bool Step02();
	virtual	bool Step03();
	virtual	bool Step04();
	virtual	bool Step05();
	virtual	bool Step06();
	virtual	bool Step07();
	virtual	bool Step08();
	virtual	bool Step09();
	virtual	bool Step10();

	/// 2011.03.23 - prodongi
	virtual void setCurChainResultIndex(int /*index*/)	{};
	void MakeChainDamage(struct _SKILL_FX* pSkillFx, SkillResult const& result, int skillId, char skillLevel, AR_HANDLE hCaster, AR_HANDLE hTarget, AR_HANDLE chainCaster);

	void				SetStep( ENUM_STEP nStep )  { m_nStep = nStep;   }

	void				GetMatrixSet( class SGameAvatarEx * pCaster, class SGameAvatarEx * pTarget, int nFxPos );
	/// 순간 위치
	void				GetFxPos( K3DMatrix &Out, class SGameAvatarEx * pAvatar );
	const K3DMatrix*	GetBoneFxMat( class SGameAvatarEx * pAvatar, int iFxPos );
	void				GetParentFXMat( class SGameAvatarEx * pAvatar, int iFxPos );
	void				GetResultMat( K3DMatrix &Out, const K3DMatrix* ParentMat, const K3DMatrix* EvPointMat, const K3DMatrix* EvPointAttachMat );

	void				GetFanShape();

	/// 중간 파일을 플레이 할지 결정
	void				PlayMiddleAnimation( SGameAvatarEx* pCaster, class KSeqForm* pSeq, struct _MOTION_FX_SET* pMoFxSet );
	void				PlaySoundFx( SGameAvatarEx* pCaster, const char* pFileName, _MOTION_FX_SET* pFxSetInfo, K3DVector* vPosition, bool bLoop = false );
	
	bool				GetSkillFx( struct SMSG_SKILL_EVENT* pMsg );
	void				MakeDamage( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	void				MakeDamageAbsorbe( SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	void				MakeAbsorbe( SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool				CheckDamage( const struct SMSG_DAMAGE* pDamage );
	void				RunScript(  const struct SMSG_DAMAGE* pDamage  );

	void				AddFxData( const AR_HANDLE & owner, const AR_HANDLE & attack, const AR_HANDLE & target, const int & nFX_ID, const int & nFX_pos );

	bool				AbsorberFlyingStyle01( KSeqForm* pSeq );
	bool				AbsorberFlyingStyle02( KSeqForm* pSeq );
	bool				AbsorberFlyingStyle03( KSeqForm* pSeq );
	void				ShootingFlyingStyle();
	K3DMatrix			GetParabolaPos( float fIncrease );

	void                calsAcc();
	void				SetFxData();
	bool				CheckNowState( class SGameAvatarEx* pAvatar );

	void				GetSpeed();
	void				GetFlyingTime( const K3DVector* pSrc, const K3DVector* pDst );

	float				RandomNumber(float fMin, float fMax);
	K3DVector			RandomNumber(K3DVector vMin, K3DVector vMax);

	void				SetDamageDisplayName( struct SMSG_DAMAGE* pDamage, SGameAvatarEx* pCaster, SGameAvatarEx* pTarget);

	void				SendSkillDamage( SGameAvatarEx* pAvatar, AR_HANDLE caster, AR_HANDLE target, SMSG_DAMAGE* pDamage );

	std::vector< SMSG_DAMAGE * >	m_DamageList; ///< 한방에 여러 타겟용
	SMSG_DAMAGE*		m_pDamage;	///< 한방에 한 타겟용

	DWORD				m_dwOldTime;	///< 전   시간
	DWORD				m_dwTime;		///< 현재 시간

	DWORD				m_dwStartTime;	///< 시작 시간
	DWORD				m_dwEndTime;	///< 끝날 시간
	DWORD				m_dwDelayTime;	///< 지연 시간

	//Process
	bool				m_bIsEnd;       ///< 끝?
	ENUM_STEP			m_nStep;        ///< 단계

	float				m_fVisibility;  ///< 투명도

	K3DVector			m_startvelocity;///< 단위(타겟포스-현재위치)
	K3DVector			m_velocity;		///< 단위(타겟포스-현재위치)
	float				m_acc;			///< 가속도

	K3DVector			m_SrcPos;
	K3DVector			m_DstPos;

	const K3DMatrix*	m_pCastMat;			///< 시전자의 위치
	const K3DMatrix*	m_pCastBoneMat;		///< 발사체가 발사될 위치나 흡수돼야될 위치
	const K3DMatrix*	m_pCasterAttachMat;
	const K3DMatrix*	m_pTargetMat;		///< 대상의 위치
	const K3DMatrix*	m_pTargetBoneMat;	///< 대상에 발사체가 도달할 위치나 흡수체가 생성돼야할 위치
	const K3DMatrix*	m_pTargetAttachMat;

	K3DMatrix			m_Matrix;

	int					m_nFxPos;       ///< 효과 위치 인덱스

	short				m_iPlayStep;

	float				m_fLength;
	//비행 관련 변수들
	float				m_fGravity;
	float				m_fOldDot;
	int					m_iFlyingStyle;
	BYTE				m_btFlyingState;
	K3DVector			m_vFrontNBackDir;
	K3DVector			m_vLeftNRightDir;

	struct _SKILL_FX*	m_pSkill_FX;

	//GameObject
	AR_HANDLE			m_caster;
	AR_HANDLE			m_target;

	class SGameAvatarEx * m_pAttack;    ///< 시전자
	class SGameAvatarEx * m_pTarget;    ///< 대상

	//Render
	class KSeqForm*			m_pCast;			///< 캐스트
	class KSeqForm*			m_pThrow;			///< 발사체
	class KSeqForm*			m_pExplosion;		///< 폭발
	class KSeqForm*			m_pReThrow;			///< 역발사체
	class KSeqForm*			m_pSubStageHit;		///< 부가 히트 FX
	class KSeqForm*			m_pSubStageFire;	///< 부가 발동 FX

	struct _MOTION_FX_SET*	m_pCastFxSet;
	struct _MOTION_FX_SET*	m_pThrowFxSet;
	struct _MOTION_FX_SET*	m_pExplosionFxSet;
	struct _MOTION_FX_SET*	m_pReThrowFxSet;


	struct _MOTION_FX_SET*	m_pSubStageHitFxSet;
	struct _MOTION_FX_SET*	m_pSubStageFireFxSet;
	DWORD					m_dwAddHitDelayTime;	///< 부가 히트FX 출력 딜레이
	DWORD					m_dwAddFireDelayTime;	///< 부가 발똥FX 출력 딜레이
	int						m_nFxSubHitPos;
	int						m_nFxSubFirePos;


	std::string				m_strSound;			///< 사운드 파일 이름		StopSound용
	int						m_iSoundIndex;		///< 사운드 파일 인덱스	StopSound용

	DWORD					m_dwFxTimeOver;		///< 시간이 초과됐지만 끝나지 않는 이펙트들을 끝낸다
	int						m_iResultIndex;

	std::vector< struct SkillResult* > m_vHPMPSPSkillResult;

	float					m_fFlyingTime;
	float					m_fDistance;
	float					m_fSpeed;

	bool					m_bMultiAttack;

	float					m_fParabolaDir;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Fire Mng - 데미지 수 만큼의 덩어리 제어
class SFireActMng : public SGameAction
{
public:
	SFireActMng( struct SMSG_SKILL_EVENT * pMsg, SGameObject * pMsgHandler );
	SFireActMng( struct SMSG_ATTACK      * pMsg, SGameObject * pMsgHandler );
	SFireActMng( SGameAction* pGameAction, struct SMSG_SKILL_EVENT * pMsg, SGameObject * pMsgHandler );
	virtual ~SFireActMng();

	virtual bool IsEnd();

	virtual bool Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	virtual bool Render( unsigned long uRenderBitVector, class KViewportObject** ppViewportList, int nViewportCount );

protected:
	std::vector< SGameAction* > m_pFireList;
	std::queue < SGameAction* > m_pReadyList;

	DWORD	m_nInterval;    ///< 간격
	int		m_nCount;       ///< 제어할 갯수
	int     m_nTotalCount;  ///< 전체 수
};

////////////////////////////////////////////////////////////////////////////
class SActionRecall : public SGameAction
{
public:
	SActionRecall(){};
	virtual ~SActionRecall(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool			Step01();
	bool			Step02();
protected:
};

////////////////////////////////////////////////////////////////////////////
class SActionReverseRecall : public SGameAction
{
public:
	SActionReverseRecall(){};
	virtual ~SActionReverseRecall(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool			Step01();
	bool			Step02();
protected:

};

////////////////////////////////////////////////////////////////////////////
class SActionAttkWeapon : public SGameAction
{
public:
	SActionAttkWeapon(){};
	virtual ~SActionAttkWeapon(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool			Step01();
	bool			Step02();
protected:

};

////////////////////////////////////////////////////////////////////////////
class SActionAttkShield : public SGameAction
{
public:
	SActionAttkShield(){};
	virtual ~SActionAttkShield(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool			Step01();
	bool			Step02();
protected:

};

////////////////////////////////////////////////////////////////////////////
class SActionMultiAttkWeapon : public SGameAction
{
public:
	SActionMultiAttkWeapon(){};
	virtual ~SActionMultiAttkWeapon(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool			Step01();
	bool			Step02();
protected:

};

////////////////////////////////////////////////////////////////////////////
class SActionAboveTwoAttk : public SGameAction
{
public:
	SActionAboveTwoAttk(){};
	virtual ~SActionAboveTwoAttk(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool			Step01();
	bool			Step02();
protected:

};

////////////////////////////////////////////////////////////////////////////
class SActionAttkAbsorber : public SGameAction
{
public:
	SActionAttkAbsorber(){};
	virtual ~SActionAttkAbsorber(){};

	void				InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool				Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool				Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool				Step01();
	bool				Step02();
	bool				Step03();
	bool				Step04();
	bool				Step05();
	bool				Step06();
	bool				Step07();
};

////////////////////////////////////////////////////////////////////////////
class SActionChargeAttk : public SGameAction
{
public:
	SActionChargeAttk(){};
	virtual ~SActionChargeAttk(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool			Step01();
	bool			Step02();
protected:
	float			m_fKnockBackSpeed;
	K3DVector		m_vKnockBackPosition;
	int				m_nEndFireMotionID;
};

////////////////////////////////////////////////////////////////////////////
class SActionShootBow : public SGameAction
{
public:
	SActionShootBow();
	virtual ~SActionShootBow();

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	void			InitFx( struct SMSG_ATTACK* pMsg );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
	void			SetResultIndex( int iResultIndex ) { m_iResultIndex = iResultIndex; };

	bool			Step01();
	bool			Step02();
	bool			Step03();
protected:
	bool				m_bNormalBow;
};

////////////////////////////////////////////////////////////////////////////
class SActionShootStrongBow : public SGameAction
{
public:
	SActionShootStrongBow(){};
	virtual ~SActionShootStrongBow(){};
	
	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
	void			SetResultIndex( int iResultIndex ) { m_iResultIndex = iResultIndex; };
	

	bool			Step01();
	bool			Step02();
	bool			Step03();
protected:
	float			m_fKnockBackSpeed;
	K3DVector		m_vKnockBackPosition;
	bool			m_bKnockBack;
};


////////////////////////////////////////////////////////////////////////////
class SActionShootAbsorberBow : public SGameAction
{
public:
	SActionShootAbsorberBow(){};
	virtual ~SActionShootAbsorberBow(){};

	void				InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool				Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool				Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
	void				SetResultIndex( int iResultIndex ) { m_iResultIndex = iResultIndex; };

	bool				Step01();
	bool				Step02();
	bool				Step03();
	bool				Step04();
	bool				Step05();
	bool				Step06();
	bool				Step07();
	bool				Step08();
};


////////////////////////////////////////////////////////////////////////////
class SActionSelfSkill : public SGameAction
{
public:
	SActionSelfSkill(){};
	virtual ~SActionSelfSkill(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool			Step01();
	bool			Step02();
protected:

};

////////////////////////////////////////////////////////////////////////////
class SActionThrowSkill : public SGameAction
{
public:
	SActionThrowSkill(){};
	virtual ~SActionThrowSkill(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
	void			SetResultIndex( int iResultIndex ) { m_iResultIndex = iResultIndex; };

	bool			Step01();
	bool			Step02();
	bool			Step03();

private:
	bool			m_bMultiThrow;
};

////////////////////////////////////////////////////////////////////////////
class SActionThrowSkillDelay : public SGameAction
{
public:
	SActionThrowSkillDelay(){};
	virtual ~SActionThrowSkillDelay(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
	void			SetResultIndex( int iResultIndex ) { m_iResultIndex = iResultIndex; };

	bool			Step01();
	bool			Step02();
	bool			Step03();

private:
	bool			m_bMultiThrow;
	float			m_fHittingDelay;
};
////////////////////////////////////////////////////////////////////////////
class SActionThrowAbsorberSkill : public SGameAction
{
public:
	SActionThrowAbsorberSkill(){};
	virtual ~SActionThrowAbsorberSkill();

	void				InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool				Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool				Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
	void				SetResultIndex( int iResultIndex ) { m_iResultIndex = iResultIndex; };

	bool				Step01();
	bool				Step02();
	bool				Step03();
	bool				Step04();
	bool				Step05();
	bool				Step06();
	bool				Step07();
	bool				Step08();
};

////////////////////////////////////////////////////////////////////////////
class SActionCreatureAbsorberSkill : public SGameAction
{
public:
	SActionCreatureAbsorberSkill(){};
	virtual ~SActionCreatureAbsorberSkill(){};

	void				InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool				Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool				Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool				Step01();
	bool				Step02();
	bool				Step03();
	bool				Step04();
	bool				Step05();
	bool				Step06();
	bool				Step07();
	bool				Step08();
};

////////////////////////////////////////////////////////////////////////////
class SActionThrowWideAreaSkill : public SGameAction
{
public:
	SActionThrowWideAreaSkill(){};
	virtual ~SActionThrowWideAreaSkill();

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool			Step01();
	bool			Step02();
private:
	struct		TARGET_DATA_LIST
	{
		TARGET_DATA_LIST()
		{
			pDamage				=	NULL;
			bDmgProcessing		=	true;
			bSubFireProcessing	=	true;
			bSubHitProcessing	=	true;
			hTarget				=	0;
		}
		
		struct SMSG_DAMAGE*		pDamage;	///< 주소만 참조한다
		bool					bDmgProcessing;
		bool					bSubFireProcessing;
		bool					bSubHitProcessing;
		AR_HANDLE				hTarget;
	};
	std::vector< TARGET_DATA_LIST >	m_vTargetList;
};

////////////////////////////////////////////////////////////////////////////
class SActionThrowWideAreaMultiSkill : public SGameAction
{
public:
	SActionThrowWideAreaMultiSkill(){};
	virtual ~SActionThrowWideAreaMultiSkill();

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
	void			SetResultIndex( int iResultIndex ) { m_iResultIndex = iResultIndex; };

	bool			Step01();
	bool			Step02();
private:
	struct		TARGET_DATA_LIST
	{
		TARGET_DATA_LIST()
		{
			pDamage				=	NULL;
			bDmgProcessing		=	true;
			bSubFireProcessing	=	true;
			bSubHitProcessing	=	true;
			hTarget				=	0;
		}
		
		struct SMSG_DAMAGE*		pDamage;	///< 주소만 참조한다
		bool					bDmgProcessing;
		bool					bSubFireProcessing;
		bool					bSubHitProcessing;
		AR_HANDLE				hTarget;
	};
	std::vector< TARGET_DATA_LIST >	m_vTargetList;

	DWORD			m_dwHitDelay;
	DWORD			m_dwStartHitTime;

	int				m_nTargetCnt;
	int				m_nCasterFxID;
};

////////////////////////////////////////////////////////////////////////////
class SActionFireMissle : public SGameAction
{
public:
	SActionFireMissle(){};
	virtual ~SActionFireMissle(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
	void			SetResultIndex( int iResultIndex ) { m_iResultIndex = iResultIndex; };


	bool			Step01();
	bool			Step02();
	bool			Step03();
	bool			Step04();
};


////////////////////////////////////////////////////////////////////////////
class SActionFireMultiMissle : public SGameAction
{
public:
	SActionFireMultiMissle(){};
	virtual ~SActionFireMultiMissle(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
	void			SetResultIndex( int iResultIndex ) { m_iResultIndex = iResultIndex; };

	bool			Step01();
	bool			Step02();
	bool			Step03();
	bool			Step04();
};

////////////////////////////////////////////////////////////////////////////
class SActionFirePenetratedMissle : public SGameAction
{
public:
	SActionFirePenetratedMissle();
	virtual ~SActionFirePenetratedMissle();

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool			Step01();
	bool			Step02();
	bool			Step03();
protected:
	struct		TARGET_DATA_LIST
	{
		TARGET_DATA_LIST()
		{
			fOldLength		=	0.0f;
			pDamage			=	NULL;
			
		}
		struct SMSG_DAMAGE*		pDamage;	///< 주소만 참조한다
		float					fOldLength;
	};
	std::vector< TARGET_DATA_LIST	>	m_vTargetList;
};

/// 2011.03.23 - prodongi
class SActionFireChainMissile : public SGameAction
{
public:
	SActionFireChainMissile(){};
	virtual ~SActionFireChainMissile(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
	void			SetResultIndex( int iResultIndex ) { m_iResultIndex = iResultIndex; };

	bool			Step01();
	bool			Step02();
	bool			Step03();
	bool			Step04();

protected:
	void setSkillEvent(struct SMSG_SKILL_EVENT const* msg);
	virtual void setCurChainResultIndex(int index);
	void setNextChainResultIndex();
	/// startIndex를 시작으로 한 skill result의 hFrom, hTarget이 유효한 skill result index를 찾는다
	int findValidHandle(int startIndex, bool caster);

protected:
	struct sSkillEvent
	{
		unsigned short	m_id;
		char			m_level;
		AR_HANDLE		m_chainCaster;
		std::vector<SkillResult> m_result;
	};
	int m_resultIndex;
	sSkillEvent m_skillEvent;
	bool m_readyNextResult;
};

////////////////////////////////////////////////////////////////////////////
class SActionLastingWideAreaSkill : public SGameAction
{
public:
	SActionLastingWideAreaSkill(){};
	virtual ~SActionLastingWideAreaSkill(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
	void			SetResultIndex( int iResultIndex ) { m_iResultIndex = iResultIndex; };

	bool			Step01();
	bool			Step02();
	bool			Step03();
};

////////////////////////////////////////////////////////////////////////////
class SActionWorkingSkill : public SGameAction
{
public:
	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
	void			SetResultIndex( int iResultIndex ) { m_iResultIndex = iResultIndex; };

	bool			Step01();
public:
	SActionWorkingSkill() {};
	virtual ~SActionWorkingSkill() {};
};

/// PathEffect 테스트용 스킬
class SActionPfxTest1 : public SGameAction
{
public:
	SActionPfxTest1(){};
	virtual ~SActionPfxTest1(){};

	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
	void			SetResultIndex( int iResultIndex ) { m_iResultIndex = iResultIndex; };


	bool			Step01();
	bool			Step02();
};

////////////////////////////////////////////////////////////////////////////
class SActionLightningFx : public SGameAction
{
private:
	class SGameLightningFx*		m_pLightningFx;
public:
	SActionLightningFx();
	virtual ~SActionLightningFx();

public:
	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool			Step01();
	bool			Step02();
};

////////////////////////////////////////////////////////////////////////////
class SActionHealingWaveFx : public SGameAction
{
private:
	class SGameHealingWaveFx*	m_pHealingWaveFx;
public:
	SActionHealingWaveFx();
	virtual ~SActionHealingWaveFx();

public:
	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool			Step01();
	bool			Step02();
};

////////////////////////////////////////////////////////////////////////////
class SActionBlessingHammer : public SGameAction
{
private:
	float			m_fHammerZOffSet;
	float			m_fHammerDistance;

	float			m_fHammerZRotation;
	DWORD			m_dwZRotationTime;
	DWORD			m_dwOldZRotationTime;

	float			m_fHammerXRotation;
	DWORD			m_dwXRotationTime;
	DWORD			m_dwOldXRotationTime;

	DWORD			m_dwHammerTime;
	DWORD			m_dwOldHammerTime;
	float			m_fMovingDistance;

	K3DVector		m_vPosition;
	K3DMatrix		m_matParent;
public:
	SActionBlessingHammer();
	virtual ~SActionBlessingHammer();

public:
	void			InitFx( struct SMSG_SKILL_EVENT* pMsg, struct _SKILL_FX* pSkillFx );
	bool			Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	bool			Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	bool			Step01();
	bool			Step02();
	bool			Step03();
};