enum {
    kCCActionTagInvalid = -1,
};

class CCAction : public CCObject
{
	bool isDone(void);
    CCNode* getTarget(void);
    // void setTarget(CCNode *pTarget);
    CCNode* getOriginalTarget(void);
    // void setOriginalTarget(CCNode *pOriginalTarget);
    int getTag(void);
    void setTag(int nTag);
    CCAction* clone();
    CCObject* copy();
};

class CCFiniteTimeAction : public CCAction
{
    float getDuration(void);
    void setDuration(float duration);
    CCFiniteTimeAction* reverse(void);
};

class CCActionInterval : public CCFiniteTimeAction
{
    float getElapsed(void);
    bool isDone(void);
    void setAmplitudeRate(float amp);
    float getAmplitudeRate(void);
    CCActionInterval* reverse(void);
};

// CCActionInterval
class CCSpeed : public CCAction
{
    float getSpeed(void);
    void setSpeed(float fSpeed);
    CCActionInterval* reverse(void);
	bool isDone(void);

    static CCSpeed* create(CCActionInterval *pAction, float fRate);
};

class CCFollow : public CCAction
{
    bool isBoundarySet(void);
    void setBoudarySet(bool bValue);
	bool isDone(void);

    static CCFollow* create(CCNode *pFollowedNode, CCRect rect);
    static CCFollow* create(CCNode *pFollowedNode);
};

class CCSequence : public CCActionInterval
{
	CCActionInterval* reverse(void);

    static CCSequence* createWithTwoActions(CCFiniteTimeAction *pActionOne, CCFiniteTimeAction *pActionTwo);
    static CCSequence* create(CCArray *actions);
};

class CCRepeat : public CCActionInterval
{
	bool isDone(void);
	CCActionInterval* reverse(void);

    static CCRepeat* create(CCFiniteTimeAction *pAction, unsigned int times);
};

class CCRepeatForever : public CCActionInterval
{
	bool isDone(void);
	CCActionInterval* reverse(void);

    static CCRepeatForever* create(CCActionInterval *pAction);
};

class CCSpawn : public CCActionInterval
{
	CCActionInterval* reverse(void);

    static CCSpawn* createWithTwoActions(CCFiniteTimeAction *pAction1, CCFiniteTimeAction *pAction2);
    static CCSpawn* create(CCArray *actions);
};

class CCRotateTo : public CCActionInterval
{

    static CCRotateTo* create(float duration, float fDeltaAngle);
};

class CCRotateBy : public CCActionInterval
{
	  CCActionInterval* reverse(void);

    static CCRotateBy* create(float duration, float fDeltaAngle);
    static CCRotateBy* create(float duration, float fDeltaAngleX, float DeltaAngleY);
};

class CCMoveTo : public CCActionInterval
{

    static CCMoveTo* create(float duration, CCPoint position);
};

class CCMoveBy : public CCActionInterval
{
	CCActionInterval* reverse(void);

    static CCMoveBy* create(float duration, CCPoint deltaPosition);
};

class CCSkewTo : public CCActionInterval
{

    static CCSkewTo* create(float t, float sx, float sy);
};

class CCSkewBy : public CCActionInterval
{
	CCActionInterval* reverse(void);

    static CCSkewBy* create(float t, float deltaSkewX, float deltaSkewY);
};

class CCJumpBy : public CCActionInterval
{
	CCActionInterval* reverse(void);

    static CCJumpBy* create(float duration, CCPoint position, float height, int jumps);
};

class CCJumpTo : public CCActionInterval
{

    static CCJumpTo* create(float duration, CCPoint position, float height, int jumps);
};

/*
 There's a bug in tolua++
 Can't use struct in lua after binding struct
 So use class instead.
*/
class ccBezierConfig {
	ccBezierConfig(void);
    CCPoint endPosition;
    CCPoint controlPoint_1;
    CCPoint controlPoint_2;
};

class CCBezierBy : public CCActionInterval
{
	CCActionInterval* reverse(void);

    static CCBezierBy* create(float t, ccBezierConfig c);
};

class CCBezierTo : public CCActionInterval
{

    static CCBezierTo* create(float t, ccBezierConfig c);
};

class CCScaleTo : public CCActionInterval
{

    static CCScaleTo* create(float duration, float sx, float sy);
    static CCScaleTo* create(float duration, float s);
};

class CCScaleBy : public CCActionInterval
{
	CCActionInterval* reverse(void);

    static CCScaleBy* create(float duration, float s);
    static CCScaleBy* create(float duration, float sx, float sy);
};

class CCBlink : public CCActionInterval
{
	CCActionInterval* reverse(void);

    static CCBlink* create(float duration, unsigned int uBlinks);
};

class CCFadeIn : public CCActionInterval
{
	CCActionInterval* reverse(void);

    static CCFadeIn* create(float d);
};

class CCFadeOut : public CCActionInterval
{
	CCActionInterval* reverse(void);

    static CCFadeOut* create(float d);
};

class CCFadeTo : public CCActionInterval
{

    static CCFadeTo* create(float duration, GLubyte opacity);
};

class CCTintTo : public CCActionInterval
{

    static CCTintTo* create(float duration, GLubyte red, GLubyte green, GLubyte blue);
};

class CCTintBy : public CCActionInterval
{
	CCActionInterval* reverse(void);

    static CCTintBy* create(float duration, GLshort deltaRed, GLshort deltaGreen, GLshort deltaBlue);
};

class CCDelayTime : public CCActionInterval
{
	CCActionInterval* reverse(void);

    static CCDelayTime* create(float d);
};

class CCReverseTime : public CCActionInterval
{
	CCActionInterval* reverse(void);

    static CCReverseTime* create(CCFiniteTimeAction *pAction);
};

class CCAnimate : public CCActionInterval
{
	CCActionInterval* reverse(void);

    CCAnimation* getAnimation(void);
    void setAnimation(CCAnimation *pAnimation);

    static CCAnimate* create(CCAnimation *pAnimation);
};

class CCTargetedAction : public CCActionInterval
{
	CCNode* getForcedTarget(void);
	void setForcedTarget(CCNode* target);

	static CCTargetedAction* create(CCNode* pTarget, CCFiniteTimeAction* pAction);
};


// CCActionInstant
class CCActionInstant : public CCFiniteTimeAction
{
	CCFiniteTimeAction* reverse(void);
	bool isDone(void);
};

class CCShow : public CCActionInstant
{
	CCFiniteTimeAction* reverse(void);

    static CCShow* create();
};

class CCHide : public CCActionInstant
{
	CCFiniteTimeAction* reverse(void);

    static CCHide* create();
};

class CCToggleVisibility : public CCActionInstant
{

    static CCToggleVisibility* create();
};

class CCFlipX : public CCActionInstant
{
	CCFiniteTimeAction* reverse(void);

    static CCFlipX* create(bool x);
};

class CCFlipY : public CCActionInstant
{
	CCFiniteTimeAction* reverse(void);

    static CCFlipY* create(bool y);
};

class CCPlace : public CCActionInstant //<NSCopying>
{
    static CCPlace* create(CCPoint pos);
};