Leviathan/Client/Game/game/GameSystem/SkillEx.h

#pragma once

#include <windows.h>
//#include <string>
#include <map>
//#include <vector>
#include <algorithm>
#include <functional>
#include <toolkit/khash.h>
#include "KTypes.h"
#include "TemplateUtil.h"
#include "Observer.h"
#include "EqExpr.h"
#include "CreatureBase.h"
#include <toolkit/c_fixed.h>

class SUIDisplayInfo;
struct SkillBaseEx;

namespace rp {

	class CSkillTooltip;
	class CSkillEx
	{
	public:

		CSkillEx();
		CSkillEx( SkillBaseEx* skill );
		operator SkillBaseEx* () { return mSkill; }
		operator const SkillBaseEx* () const { return mSkill; }
		SkillBaseEx* operator -> () { return mSkill; }
		const SkillBaseEx* operator -> () const { return mSkill; }
		void bind( SkillBaseEx* skill );
		void level( int _level ) { mUseLv = _level; }
		int level() const { return mUseLv; }
		void enhance( int enhanceLv ) { mEnhance = enhanceLv; }
		int enhance() const { return mEnhance; }
		void userAttribute( const CreatureAttribute& attribute, const CreatureAttribute& itemAttribute ) { mUserAttribute = attribute; mItemAttribute = itemAttribute; }
		const CreatureAttribute& userAttribute() const { return mUserAttribute; }
		const CreatureAttribute& itemAttribute() const { return mItemAttribute; }
		bool isRecoverable() const;
		void setMaxMP(int mp)	{	maxMP = mp;		}	/// 2011.05.27 - prodongi
		int getMaxMP() const	{	return maxMP;	}
		void setCurMP(int mp)	{	curMP = mp;		}	/// 2011.05.27 - prodongi
		int getCurMP() const	{	return curMP;	}
	private:
		SkillBaseEx*				mSkill;
		int							mUseLv;
		int							mEnhance;
		CreatureAttribute			mUserAttribute;
		CreatureAttribute			mItemAttribute;
		int							maxMP;
		int							curMP;
	};

	class CSkillExSubject;
	// #2.1.2.12
	// 2010.05.17 - prodongi
	typedef rp::expr< float > fx_expr;
//	typedef rp::expr< c_fixed10 > fx_expr;

	class CSkillExValue : public mixin::observable, public fx_expr::Numeric
	{
	public:
		CSkillExValue( CSkillExSubject* subject ) : Subject( subject ), Numeric( 0 ) {}
		virtual ~CSkillExValue() {}
		virtual void update() = 0;
	protected:
		CSkillExSubject* Subject;
	};

	class CSkillExSubject : public mixin::subjectable, public fx_expr::Factory
	{
	public:
		CSkillExSubject() : SkillEx( 0 ), EnchantSkillEx(0) {}
		virtual ~CSkillExSubject() {}
		void appendVariable( const char* key, CSkillExValue* value )
		{
			subjectable::attach( value );
			Factory::appendExpression( key, value );
		}
		const CSkillEx& getSkill() const { return *SkillEx; }
		const CSkillEx& getEnchantSkill() const { return *EnchantSkillEx; }	/// 2011.05.17 - prodongi
		bool isEnchantSkill() const	{	return EnchantSkillEx != NULL;	}
		void setSkill( const CSkillEx& skillEx ) 
		{ 
			SkillEx = &skillEx;
			EnchantSkillEx = NULL;	/// 2011.05.17 - prodongi
			subjectable::notify();
		}
		/// 2011.05.17 - prodongi
		void setSkill(const CSkillEx& skillEx, const CSkillEx& enchantSkillEx)
		{
			SkillEx = &skillEx;
			EnchantSkillEx = &enchantSkillEx;
			subjectable::notify();
		}
	private:
		const CSkillEx* SkillEx;
		const CSkillEx* EnchantSkillEx;	/// 2011.05.17 - prodongi
	};

	class CSkillExFxValue : public CSkillExValue
	{
	public:
		CSkillExFxValue( int index, CSkillExSubject* subject ) : CSkillExValue( subject ), m_FxValueIndex( index ) {}
		virtual void update();
	private:
		int m_FxValueIndex;
	};

	class CSkillExValueSkillLv : public CSkillExValue
	{
	public:
		CSkillExValueSkillLv( CSkillExSubject* subject ) : CSkillExValue( subject ) {}
		virtual void update();
	};

	class CSkillExValueEnhancePoint : public CSkillExValue
	{
	public:
		CSkillExValueEnhancePoint( CSkillExSubject* subject ) : CSkillExValue( subject ) {}
		virtual void update();
	};

	class CSkillExValueUserAttack : public CSkillExValue
	{
	public:
		CSkillExValueUserAttack( CSkillExSubject* subject ) : CSkillExValue( subject ) {}
		virtual void update();
	};

	class CSkillExValueUserMagic : public CSkillExValue
	{
	public:
		CSkillExValueUserMagic( CSkillExSubject* subject ) : CSkillExValue( subject ) {}
		virtual void update();
	};

	/// 2011.04.26 - prodongi
	class CSkillExValueCoolTime : public CSkillExValue
	{
	public:
		CSkillExValueCoolTime( CSkillExSubject* subject ) : CSkillExValue( subject ) {}
		virtual void update();
	};

	class CSkillExSvValueConsumeBaseHP : public CSkillExValue
	{
	public:
		CSkillExSvValueConsumeBaseHP( CSkillExSubject* subject ) : CSkillExValue( subject ) {}
		virtual void update();
	};

	class CSkillExSvValueConsumeSlvHP : public CSkillExValue
	{
	public:
		CSkillExSvValueConsumeSlvHP( CSkillExSubject* subject ) : CSkillExValue( subject ) {}
		virtual void update();
	};

	/// 2011.05.19 - prodongi
	class CSkillExValueMP : public CSkillExValue
	{
	public:
		CSkillExValueMP( CSkillExSubject* subject ) : CSkillExValue( subject ) {}
		virtual void update();
	};

	/// 2011.05.19 - prodongi
	class CSkillExValueCastingDelay : public CSkillExValue
	{
	public:
		CSkillExValueCastingDelay( CSkillExSubject* subject ) : CSkillExValue( subject ) {}
		virtual void update();
	};

	/// 2011.05.27 - prodongi
	class CSkillExValueMaxMP : public CSkillExValue
	{
	public:
		CSkillExValueMaxMP( CSkillExSubject* subject ) : CSkillExValue( subject ) {}
		virtual void update();
	};

	/// 2011.05.27 - prodongi
	class CSkillExValueCurMP : public CSkillExValue
	{
	public:
		CSkillExValueCurMP( CSkillExSubject* subject ) : CSkillExValue( subject ) {}
		virtual void update();
	};

	class ISkillTooltipComposer
	{
	public:
		virtual ~ISkillTooltipComposer() {}
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern ) = 0;
		virtual void setDefaultTag( const char* tag ) {}
	};

	class CSkillTooltip
	{
	public:
		CSkillTooltip() {}
		~CSkillTooltip();
		CSkillTooltip* append( const char* key, ISkillTooltipComposer* composer );
		ISkillTooltipComposer* find( const char* key );
		void compose( const CSkillEx& skill, std::string& tooltip );
	private:
		typedef std::map< std::string, ISkillTooltipComposer* > composer_map_t;
		composer_map_t	mComposerMap;
	};

	class CSkillEmptyDeco : public ISkillTooltipComposer
	{
	public:
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	};

	class CSkillLvDeco : public ISkillTooltipComposer 
	{
	public: 
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	};

	class CSkillAttributeIconDeco : public ISkillTooltipComposer
	{
	public:		
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	};

	class CSkillHpDeco : public ISkillTooltipComposer
	{
	public:		
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	};

	class CSkillMpDeco : public ISkillTooltipComposer
	{
	public:		
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	};

	class CSkillAggroDeco : public ISkillTooltipComposer
	{
	public:		
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	};

	class CSkillAggroTypeDeco : public ISkillTooltipComposer
	{
	public:		
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	};

	class CSkillCastingTimeDeco : public ISkillTooltipComposer
	{
	public:
		CSkillCastingTimeDeco( SUIDisplayInfo* helper ) : Helper( helper ) {}
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	private:
		SUIDisplayInfo* Helper;
	};

	/// 2011.06.20 - prodongi
	class CSkillCoolTimeDeco : public ISkillTooltipComposer
	{
	public:
		CSkillCoolTimeDeco( SUIDisplayInfo* helper ) : Helper( helper ) {}
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	private:
		SUIDisplayInfo* Helper;
	};

	class CSkillCriticalBonusDeco : public ISkillTooltipComposer
	{
	public:		
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	};

	class CSkillEnhanceDeco : public ISkillTooltipComposer
	{
	public:		
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	};

	class CSkillImproveMpCostDeco : public ISkillTooltipComposer
	{
	public:		
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	};

	class CSkillImproveCastingTimeDeco : public ISkillTooltipComposer
	{
	public:
		CSkillImproveCastingTimeDeco( SUIDisplayInfo* helper ) : Helper( helper ) {}
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	private:
		SUIDisplayInfo* Helper;
	};

	class CSkillImproveCoolTimeDeco : public ISkillTooltipComposer
	{
	public:
		CSkillImproveCoolTimeDeco( SUIDisplayInfo* helper ) : Helper( helper ) {}
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	private:
		SUIDisplayInfo* Helper;
	};

	class CSkillImproveHitBonusDeco : public ISkillTooltipComposer
	{
	public:		
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	};

	class CSkillImproveAggroDeco : public ISkillTooltipComposer
	{
	public:		
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	};

	class CSkillFxDeco : public ISkillTooltipComposer
	{
	public:
		CSkillFxDeco( CSkillExSubject* Subject ) : ISkillTooltipComposer(), m_Subject( Subject ) {}
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
		virtual void setDefaultTag( const char* tag );
	protected:
		void compileSkill(const CSkillEx& skill, std::string& result);
	private:
		CSkillExSubject* 	m_Subject;
		std::string		 	m_DefaultTag;
	};

	class CSkillStateFxDeco : public ISkillTooltipComposer
	{
	public:
		CSkillStateFxDeco( CSkillExSubject* Subject, SUIDisplayInfo* Helper ) : ISkillTooltipComposer(), m_Subject( Subject ), m_Helper( Helper ) {}
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	private:
		// 2010.06.03 - prodongi
		void gatherStateFxIDFrom( const CSkillEx& Skill, std::vector<int>& StateFxIDs, std::vector<int>& stateLevel );
//		std::vector< int > gatherStateFxIDFrom( const CSkillEx& Skill );
		// 2010.06.03 - prodongi
		/// 2010.11.18 - prodongi
		void getStateFxDetail( int StateFxID, std::string& StateFxDetail, int _stateFxLevel, int skillEnhance );
		//void getStateFxDetail( int StateFxID, std::string& StateFxDetail );
		bool isSystemStateFx( int stateFxID ) const;
		CSkillExSubject*	m_Subject;
		SUIDisplayInfo*		m_Helper;
	};

	// 2010.05.17 - prodongi
	class CSkillPassiveFxDeco : public ISkillTooltipComposer
	{
	public:
		CSkillPassiveFxDeco( CSkillExSubject* Subject, SUIDisplayInfo* Helper ) : ISkillTooltipComposer(), m_Subject( Subject ), m_Helper(Helper) {}
		virtual void compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern );
	private:
		std::string parameterIncAmp(const CSkillEx& skill, bool amplify);
		std::string getParameterTypeABitSetText(const CSkillEx& skill, int strId, int varPos, bool amplify);
		std::string getParameterTypeBBitSetText(const CSkillEx& skill, int strId, int varPos, bool amplify);

	private:
		CSkillExSubject* 	m_Subject;
		SUIDisplayInfo*		m_Helper;
	};
} // namespace rappelz