#pragma once

#include "K3DTypes.h"
#include "SGameAvatarEx.h"

class KViewportObject;
class KSeqModel;

namespace 
{
	enum EFFECT_FILE
	{
		EFFECT_START_FILE = 0,
		EFFECT_MIDDLE_FILE,
		EFFECT_END_FILE,
		EFFECT_FILE_MAX,
	};
};

class SGamePreLoad
{
public:
	SGamePreLoad();
	~SGamePreLoad();

	void RequestThreadLoading(  int nFXSet_ID, bool bNotCacheDelete = false );
	void RequestThreadLoading(  struct _SKILL_FX* pSkill_fx, bool bNotCacheDelete = false );

	void Unload( struct _SKILL_FX* pSkill_fx );
protected:
	void _loadFX( int nFXSet_ID, bool bNotCacheDelete );
	void _unloadFX( int nFXSet_ID );
};

/** 게임상의 Effect
특정 위치에서 폭발
특정 위치 쫓아가기 */
//=============================================================================================================================
//New
class SGameEffectEx : public SGameObject
{
public:
	enum
	{
		NORMAL_MODE = 0, ///< 기본 모드
		STATE_MODE,  ///< 상태 이상 모드
	};

	enum		FX_PLAY_STATE
	{
		PLAY_NORAML = 0,
		PLAY_LOOP,
		PLAY_END,
	};

	SGameEffectEx( struct FX_DATA * pFX_data, struct _MOTION_FX_SET* pFX_SET );
	~SGameEffectEx();

	void      SetOwner( AR_HANDLE owner )   { m_hOwner = owner; }
	void	  SetCaster( AR_HANDLE caster ) { m_hCaster = caster; }
	void	  setTarget(AR_HANDLE target)	{ m_target = target;	}	/// 2011.04.04 - prodongi
	AR_HANDLE GetOwner()                    { return m_hOwner;  }
	void SetEffectID( int nEffectID )		{ m_nEffectID = nEffectID; }
	int	 GetEffectID()						{ return  m_nEffectID; }

	void PlayAnimation( DWORD time, int nAniType = SEQTYPE_NORMAL, float fPlayRate = 4.8f );
	virtual bool Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	virtual bool Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );

	void SetDirection( K3DVector &pos, K3DVector &target );
	void SetParentMat( K3DMatrix *pParentMat, const K3DMatrix *pAttachtMat, const K3DMatrix* pEvpMat )
	{ 
		m_pParentMat		= pParentMat; 
		m_pAttachMat		= pAttachtMat; 
		m_pEvPointMatrix	= pEvpMat; 
	}

	void	SetEventPointSequencer( class KEventPointSeq * pEvPointSeq );

	bool	IsPlaying();
	bool	IsEnd() { return m_bEnd; }

	void	SetMode( int nMode );
	int		GetMode() { return m_nMode; }
	void	SetEndTime( AR_TIME end_time ) { m_arEndTime = end_time; }

	void	ForceEnd() { SetEnd(); }

	void	IsLoopFx( bool bLoop )
	{ 
		if( bLoop ) 
			m_nFxPlayState	=	PLAY_LOOP;
		else if( m_nFxPlayState == PLAY_LOOP )
		{
			if( getStep() == STEP00 )
			{
				setStep(STEP01);
			}
			m_nFxPlayState	=	PLAY_END;
		}
	}

	void	IsWeaponEffectPos()
	{ 
		m_bIsWeaponEffectPos	=	true; 
		m_bIsDir				=	false;
	}

	unsigned short GetStateHandle()	{ return m_StateHandle; }
	void	SetStateHandle( unsigned short nStateHandle )	{ m_StateHandle = nStateHandle; }

	void	SetTargetScale(float fSize, K3DMatrix & matTransform );
	void	SetScaleAdjust(float f) { m_fScaleAdjust = f; }
protected:
	void	SetEnd() { m_bEnd = true; }
	void	setSound( int nPlayRatio, const char *pSoundName, int nVol, bool bLoop, bool bSoundOption[SOUND_OP_MAX] );
	void	_processPlayAni( bool bIsEffect , int nIndex, int nNextIndex, int nNextStep, int nPlayAniType = SEQTYPE_NORMAL );
	void    procSyncTargetAdjustedScale();	/// 2011.04.04 타겟의 조정된 스케일 값과 동기화 - prodongi

	enum
	{
		STEP00,
		STEP01,
		STEP02,
	};

	int  getStep()            { return m_nStep;  }
	void setStep( int nStep ) { m_nStep = nStep; }

	AR_HANDLE     m_hOwner;
	AR_HANDLE	  m_hCaster;
	AR_HANDLE	  m_target;		/// 2011.04.04 타겟의 스케일이 변했을 때 체크하기 위해 추가함 - prodongi

	bool		  m_bIsDir;

	int			  m_nStep;

	int			  m_nMode; ///< 기본 모드, 상태 이상 모드
		
	int			  m_nEffectID;

	bool		  m_bIsSound[EFFECT_FILE_MAX];

	bool		  m_bIsEffect[EFFECT_FILE_MAX];
	KSeqModel *   m_pSeq;   ///< Effect

	bool		  m_bEnd;

	bool		  m_bIsWeaponEffectPos;

	FX_PLAY_STATE m_nFxPlayState;

	int				m_nSoundID;
	std::string		m_SoundName;
	bool			m_bIsSoundLoop;

	_MOTION_FX_SET* m_pFX_SET;
	struct FX_DATA* m_pFX_DATA;

	const K3DMatrix	 *m_pEvPointMatrix; ///< 이벤트 매트릭스
	const K3DMatrix	 *m_pAttachMat;	///< 뼈 매트릭스
	K3DMatrix    *m_pParentMat;		///< 부모 위치

	K3DMatrix    m_LocalMat;
	K3DMatrix    m_ResultMat;

//	class KEventPointSeq * m_pEvPointSeq;
	K3DMatrix    m_DirectionMat;

	DWORD		 m_dwTime;
	AR_TIME      m_arEndTime;

	DWORD		 m_dwPlayTime;
	int          m_nCurAniType;
	float        m_fCurPlayRate;

	unsigned short m_StateHandle; ///< 상태 이상 핸들

	bool			m_bTargetSize;
	K3DMatrix		m_matTransform;

	std::string		m_strEffectFileName[EFFECT_FILE_MAX];
	std::string		m_strSoundFileName[EFFECT_FILE_MAX];

	float			m_fScaleAdjust;
};

//=============================================================================================================================
//=============================================================================================================================
/// Old 정리 해서 삭제 시키자.
class SGameEffect : public SGameObject
{
public:
	SGameEffect(AR_HANDLE owner=0, AR_HANDLE state_handle = 0, AR_TIME endtime = 0 );
	virtual ~SGameEffect(void);

	int	 GetEffectID()                      { return m_nEffectID;	   }
	void SetEffectID( int nEffectID )		{ m_nEffectID = nEffectID; }
	void AddEffect( const char * pName );

	void PlayAnimation( DWORD time, int nAniType = SEQTYPE_NORMAL, float fPlayRate = 4.8f );

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

	void SetFlag( int nFlag ) { m_nFlag = nFlag; }
 
	void SetDirection( K3DVector &pos, K3DVector &target );
	void SetOwnerDirection( K3DMatrix* pParantMatrix, K3DVector* pDirection );
	void SetParentMat( K3DMatrix *pParentMat, const K3DMatrix *pAttachtMat, const K3DMatrix* pEvpMat  )
	{
		m_pParentMat		=	pParentMat; 
		m_pAttachMat		=	pAttachtMat; 
		m_pEvPointMatrix	=	pEvpMat;
	}

	void SetEndTime( AR_TIME arEndTime ) { m_arEndTime = arEndTime; }
	void SetEnd() { m_bEnd = TRUE; }
	bool IsPlaying();
	BOOL IsEnd() { return m_bEnd; }
	AR_HANDLE     GetHandle()		{ return m_hOwner; }
	unsigned short     GetStateHandle()	{ return m_StateHandle; }
	void SetStateHandle( unsigned short nStateHandle )	{ m_StateHandle = nStateHandle; }

	void SetEventPointSequencer( class KEventPointSeq * pEvPointSeq );
	void SetTargetScale(float fSize, K3DMatrix & matTransform);
protected:
	int			  m_nFlag;
	BOOL		  m_bEnd;
	AR_HANDLE     m_hOwner; ///< 소유자
	
	int			  m_nEffectID; ///< Effect ID, 삭제시 필요

	unsigned short m_StateHandle; ///< 상태 이상 핸들
	AR_TIME		   m_arEndTime;   ///< 상태 이상 끝나는 시간

	KSeqModel *   m_pSeq;   ///< Effect

	K3DVector    m_Pos;    ///< 위치
	K3DVector    m_Target; ///< 타겟 위치

	const K3DMatrix	 *m_pEvPointMatrix; ///< 이벤트 매트릭스
	const K3DMatrix  * m_pAttachMat; ///< 상대적인 위치(머리, 팔, 발 등등)
	 K3DMatrix    * m_pParentMat; ///< 부모 위치
	K3DVector	 * m_pOwnerDirection;
	K3DMatrix    m_LocalMat;
	K3DMatrix    m_ResultMat;

//	class KEventPointSeq * m_pEvPointSeq;
	K3DMatrix    m_DirectionMat;

	DWORD		 m_dwTime;

	DWORD		 m_dwPlayTime;
	int          m_nCurAniType;
	float        m_fCurPlayRate;

	DWORD		 m_dwPlayEndTime; ///< Play 가 끝난 시점

	bool		 m_bIsOwnerDir;

	bool			m_bTargetSize;
	K3DMatrix		m_matTransform;
#ifndef NDEBUG
	std::string	m_strFileName;
#endif
};
//Play 방법 : 정상 한번, 거꾸로 한번,  


//////////////////////////////////////////////////////////
/// 근접 공격 힛팅 이펙트
class SGameAttackEffect : public SGameObject
{
private:
	KSeqModel *				m_pSeq;

	bool					m_bTargetSize;
	bool					m_bEnd;

	K3DMatrix				m_ResultMat;

	AR_HANDLE				m_hCast;
	AR_HANDLE				m_hTarget;
public:
	void					SetEnd() { m_bEnd = true; }
public:
	bool					IsPlaying();
	bool					IsEnd() { return m_bEnd; }
public:
	AR_HANDLE				GetCastHandle() { return m_hCast; }
public:
	virtual bool Process( DWORD dwTime, unsigned long uProcessBitVector=0 );
	virtual bool Render( unsigned long uRenderBitVector, KViewportObject** ppViewportList, int nViewportCount );
public:
	SGameAttackEffect();
	virtual ~SGameAttackEffect();
};