/* =====================================================================
* ÆÄ    ÀÏ :	SkillObject.h , SkillObject.cpp
* ¸ñ    Àû :	»ç¿ëÁßÀÎ ½ºÅ³ °´Ã¼ , »ó¼ÓÀ» ¹Þ¾Æ »ç¿ëÇÑ´Ù.
* ÀÛ ¼º ÀÚ :	À̹ý¼®
* ÀÛ ¼º ÀÏ :    2007³â 7¿ù 13ÀÏ
*
* Ãß°¡³»¿ë :
*		Ãß°¡³¯Â¥    ÀÛ¾÷ÀÚ	  Ãß°¡³»¿ë
* 
* ÁÖÀÇ»çÇ× :	.
* =======================================================================*/
#pragma once
#include "BaseObject_Common.h"
#include "DramaturgyInfo.h"
#include "Skill_Common.h"

struct sTargetDamage;
struct sTargetHeal;

enum eAPPLYDRAMA_TYPE;

class cDynamicSceneNode;
class cEffectSceneNode;
class cSoundSceneNode;
struct sTrailInfo;

class cBaseObject;
class cBulletObj;

struct sApplyDrama
{
	sObject mTargetObj;
	cDramaturgyInfo* mpInfo;
};

struct sLoopEffect
{
	unsigned long mIdxByManager;
	cEffectSceneNode* mEffectNode;

	sLoopEffect()
	{
		mIdxByManager = (unsigned long)-1;
		mEffectNode = 0;
	}
};

struct sLoopSound
{
	unsigned long mIdxByManager;
	cSoundSceneNode* mSoundNode;

	sLoopSound()
	{
		mIdxByManager = (unsigned long)-1;
		mSoundNode = 0;
	}
};

///
class cDramaturgyObject 
{
public:
	virtual ~cDramaturgyObject();

	virtual void Process( unsigned long time ) = 0;

	/// TODO:
	/// ´ë»ó¿¡°Ô °´Ã¼¸¦ ¸µÅ© Çϸ鼭
	/// Á¦°Å ÇÏ´Â ·çƾÀ» ³Ö¾î¾ß ÇÑ´Ù.
	/// Thread¿¡ °É¸é¼­ Ãß°¡ 󸮵µ ÇÑ´Ù.

	/// TODO : 
	/// ¿¬Ãâ »óÅ º¯°æ ÇÔ¼ö
	inline eDRAMASTATE GetDramaState() { return mCurrentState; }
	inline void SetDramaState( eDRAMASTATE state ) { mCurrentState = state; }

	inline unsigned long	GetManagedKey() { return mManagedKey; }
	inline unsigned long	GetSkillIdx() { return mSkillIdx; }

	void	Removed() { mRemoved = true; }
	bool	IsRemoved() { return mRemoved; }

protected:
	virtual void UpdateDramaObject( sDramaActionBase* pBase, bool bTarget = false, const NiPoint3& dir = -NiPoint3::UNIT_Y );
	virtual void UpdateTrailObject( sDramaActionBase* pBase );
	virtual void AddLoopEffect( cEffectSceneNode* pNode );
	virtual void AddLoopSound( cSoundSceneNode* pNode );
	virtual void AddLoopTrail( sTrailInfo* pInfo );

	void ChangeDramaState( eDRAMASTATE state );

protected:
	cDramaturgyObject();

	/// ¿¬Ãâ »óÅ Á¦¾î ±¸Á¶Ã¼
	struct sDramaStateController
	{
		sDramaStateController()
			: pAct(0), startTime(ULONG_MAX)
		{
			animationIdx = UINT_MAX;
		}
		sDramaActionBase*	pAct;
		unsigned int		animationIdx;


		unsigned long	startTime;

		tPointerList<void*>	mLoopEffect;
		tPointerList<void*>	mLoopSound;
		tPointerList<void*>	mLoopTrail;
	};

	/// °´Ã¼ º¸°ü¼Ò¿¡ ´ëÇÑ ÂüÁ¶ Á¤º¸
	unsigned long			mManagedKey;

	/// ½ºÅ³ Á¤º¸
	unsigned long			mSkillIdx;

	/// ¿¬Ãâ Á¤º¸
	eDRAMASTATE				mCurrentState;
	cDramaturgyInfo*		mpDramaInfo;

	cDynamicSceneNode*		mViewNode;

	/// Àû¿ë ¿¬Ãâ Á¤º¸
	sDramaStateController	mApplyController;

	bool			mRemoved;

};

//////////////////////////////////////////////////////////////////////////
enum eSPECIAL
{
	eSpecial_None = 0,
	eSpecial_Field,
	eSpecial_Blink,

	eSpecial_MapChange,
	eSpecial_Vehicle,
};

///
class cSkillObject : public cDramaturgyObject
{
public:
	cSkillObject();
	virtual ~cSkillObject();

	void*			operator new( size_t n ); 
	void			operator delete( void* ptr );

	enum eVERIFY
	{
		eVerify_Faile = 0,
		eVerify_Wait,
		eVerify_Success,
	};

	virtual bool Init( unsigned long skillIdx, float speedFactor );

	virtual void Process( unsigned long time );

	void			SetManagedKey( unsigned long key, bool isDummy ) { mManagedKey = key; mIsDummy = isDummy; }
	bool			IsDummySkill() { return mIsDummy; }

	void			WaitCancel();

	unsigned int	GetSpecialType() { return mSpecialType; }

	void			EndCast();

protected:
	/// ij½ºÆà ó¸®
	void			ProcessCasting( unsigned long time );
	/// ¹ßµ¿ ó¸®
	void			ProcessActivity( unsigned long time );
	/// Àû¿ë ó¸®
	void			ProcessApply( unsigned long time );

	void			ApplyDamage( const sDramaActionBase* pAct );
	void			ApplyHeal( const sDramaActionBase* pAct );

	virtual void	AddLoopEffect( cEffectSceneNode* pNode );
	virtual void	AddLoopSound( cSoundSceneNode* pNode );
	virtual void	AddLoopTrail( sTrailInfo* pInfo );

	void FadeOutAllLoopEffect();
	void FadeOutAllSoundEffect();
	void RemoveAllTrail();

	void			ChangeDramaState( eDRAMASTATE state );

	/// ¹ß»çü
	void AddBulletObject( sDramaActionBase* pBase );

	void BulletProcess( unsigned long time );

protected:
	struct sDamageInfo
	{
		tArray<void*> damageArr;
		sObject obj;

		unsigned int viewCnt;

		sDamageInfo() : viewCnt(0) {}

		~sDamageInfo()
		{
			if( damageArr.IsEmpty() == false )
			{
				for( unsigned int i = 0, end = damageArr.GetSize(); i < end; ++i )
				{
					delete (sTargetDamageDetail*)damageArr[i];
				}
				damageArr.Clear();
			}
		}
	};

	enum
	{
		ePRINT_NONE =0,
		ePRINT_DAMAGE,
		ePRINT_HEAL,
	};

	/// ÀÎÁõ ¿©ºÎ
	bool					mIsDummy;

	eVERIFY					mVerifyState;

	/// ij½ºÆà ¿¬Ãâ Á¤º¸
	sDramaStateController	mCastingController;

	/// ¹ßµ¿ ¿¬Ãâ Á¤º¸
	sDramaStateController	mActivityController;

	/// ½ÃÀüÀÚ Á¤º¸
	unsigned char			mUserWeapon;

	/// damage Àû¿ë Ÿ°Ù
	unsigned char			mPrintType;
	tArray<void*>			mTargetObjArray;

	/// ¹ß»çü °ü¸®
	tPointerList<void*>		mBulletList;
	tArray<void*>			mDelBulletArray;

	/// Apply Drama °ü¸®
	tPointerList<void*>		mApplyDramaList;

	/// µ¿ÀÛ speed º¯¼ö
	float	mSpeedFactor;

	unsigned long mCastingTime;

	bool	mUsedAnimation;

	eSPECIAL	mSpecialType;
	NiPoint3 mFieldPos;

	//	bool	mUseFieldTarget;
};
//////////////////////////////////////////////////////////////////////////

///
class cInfluenceObject : public cDramaturgyObject
{
public:
	cInfluenceObject();
	virtual ~cInfluenceObject();

	void*			operator new( size_t n ); 
	void			operator delete( void* ptr );

	virtual bool Init( unsigned long uniqueIdx, unsigned long influenceIdx, bool isbuff );

	/// Àû¿ë¿¡ ´ëÇÑ Ã³¸®¸¸ Á¸Àç
	virtual void Process( unsigned long time );

	/// ½ÇÁ¦·Î process½ÃÀÛÇϴ ŸÀÌ¹Ö Á¦¾î¿ë
	void StartProcess( long restTime = -1, bool onlyLoopEffect = false );

	enum
	{
		eTick_HP,
		eTick_MP,
	};

	void SetTickInfo( unsigned char tickType, long value );

	inline void SetRestTime( unsigned long restTime ) { mRestTime = restTime; }
	inline unsigned long GetRestTime() { return mRestTime; }

	inline unsigned long	GetInfluenceIdx() { return mInfluenceIdx; }

	/// hero È¿°úÀÎ °æ¿ì 󸮸¦ À§Çؼ­
	inline bool IsHeroInfluence() { return mIsHeroInfluce; }
	inline bool IsAuraType() { return mInfluenceType == eINFLUENCETYPEDETAIL_AURA; }
	inline bool IsStatic() { return mStaticInfluence; }

protected:
	void ApplyHP( sDramaActionBase* pAct );
	void ApplyMP( sDramaActionBase* pAct );

protected:
	bool			mIsBuff;

	bool			mCheckBlink;
	bool			mIsHeroInfluce;
	bool			mOnlyShowLoopEffect;
	unsigned long	mBlinkTime;

	unsigned long	mStartTime;
	unsigned long	mLifeTime;

	unsigned long	mRestTime;

	bool			mStartTimeCheck;

	unsigned long	mInfluenceIdx;
	bool			mStaticInfluence;
	unsigned long	mInfluenceType;

	/// tickÈ¿°ú ¿¡¼­ »ç¿ëÇÑ´Ù.
	bool			mTickInit; /// ÃÖÃÊ¿¬Ãâ¿¡¼± Á¦¿Ü½ÃÅ°±âÀ§ÇÑ..
	bool			mTickInfluence;
	unsigned char	mTickType;
	float			mTickValue;
};

class cApplyObject : public cDramaturgyObject
{
public:
	cApplyObject();
	virtual ~cApplyObject();

	void*			operator new( size_t n ); 
	void			operator delete( void* ptr );

	/// apply drama¿¡¼­ Á¤º¸¸¦ ȹµæÇÑ´Ù.
	virtual bool Init( unsigned long managedKey, unsigned char weaponType, eAPPLYDRAMA_TYPE type );

	/// È¿°ú¹øÈ£·Î Apply¸¸À» °¡Á®¿Â´Ù.(item È¿°ú Àû¿ëµî¿¡ »ç¿ë)
	virtual bool Init( unsigned long managedKey, unsigned long influenceIdx );

	virtual void Process( unsigned long time );

private:

	enum
	{
		eINDEX_DRAMA,
		eINDEX_INFLUENCE,
	};

	unsigned char		mUserWeapon;

	/// drama or influence
	unsigned char		mIndexType;
	///
	unsigned long		mApplyIndex;

	//	eAPPLYDRAMA_TYPE	mApplyType;
	//	unsigned long		mInfluenceIdx;
};