所有的间隔动作
代码：
/**
* @addtogroup actions
* @{
*/
/** @class ActionInterval
@brief An interval action is an action that takes place within a certain period of time.
It has an start time, and a finish time. The finish time is the parameter
duration plus the start time.
These ActionInterval actions have some interesting properties, like:
- They can run normally (default)
- They can run reversed with the reverse method
- They can run with the time altered with the Accelerate, AccelDeccel and Speed actions.
For example, you can simulate a Ping Pong effect running the action normally and
then running it again in Reverse mode.
Example:
Action *pingPongAction = Sequence::actions(action, action->reverse(), nullptr);
*/
/// 间隔动作，继承自有限动作（不会无限是执行下去）
/// 间隔动作是一个会在确定时间段内执行的动作
/// 这种动作有一个开始时间和结束时间，结束时间是开始时间加上持续时间
class CC_DLL ActionInterval : public FiniteTimeAction
{
public:
/** How many seconds had elapsed since the actions started to run.
*
* @return The seconds had elapsed since the ations started to run.
*/
/// 从这个动作开始到现在已经过去了多场时间，这个时间是按秒计算的
inline float getElapsed(void) { return _elapsed; }
/** Sets the ampliture rate, extension in GridAction
*
* @param amp The ampliture rate.
*/
/// 设置振幅的频率，从GirdAction扩展而来
void setAmplitudeRate(float amp);
/** Gets the ampliture rate, extension in GridAction
*
* @return The ampliture rate.
*/
/// 得到振幅频率
float getAmplitudeRate(void);
//
// Overrides
//
virtual bool isDone(void) const override;
/**
* @param dt in seconds
*/
virtual void step(float dt) override;
virtual void startWithTarget(Node *target) override;
virtual ActionInterval* reverse() const override
{
CC_ASSERT(0);
return nullptr;
}
virtual ActionInterval *clone() const override
{
CC_ASSERT(0);
return nullptr;
}
CC_CONSTRUCTOR_ACCESS:
/** initializes the action */
/// 初始化动作
bool initWithDuration(float d);
protected:
float _elapsed;
bool _firstTick;
};
/** @class Sequence
* @brief Runs actions sequentially, one after another.
*/
/// 序列动作
/// 传入一个动作数组，这个动作就会按顺序执行数组中的动作
class CC_DLL Sequence : public ActionInterval
{
public:
/** Helper constructor to create an array of sequenceable actions.
*
* @return An autoreleased Sequence object.
*/
#if (CC_TARGET_PLATFORM == CC_PLATFORM_WP8) || (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
// WP8 in VS2012 does not support nullptr in variable args lists and variadic templates are also not supported
// WP8 在VS2012中不支持可变的参数，可变参数模板也不支持
typedef FiniteTimeAction* M;
static Sequence* create(M m1, std::nullptr_t listEnd) { return variadicCreate(m1, NULL); }
static Sequence* create(M m1, M m2, std::nullptr_t listEnd) { return variadicCreate(m1, m2, NULL); }
static Sequence* create(M m1, M m2, M m3, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, NULL); }
static Sequence* create(M m1, M m2, M m3, M m4, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, NULL); }
static Sequence* create(M m1, M m2, M m3, M m4, M m5, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, m5, NULL); }
static Sequence* create(M m1, M m2, M m3, M m4, M m5, M m6, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, m5, m6, NULL); }
static Sequence* create(M m1, M m2, M m3, M m4, M m5, M m6, M m7, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, m5, m6, m7, NULL); }
static Sequence* create(M m1, M m2, M m3, M m4, M m5, M m6, M m7, M m8, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, m5, m6, m7, m8, NULL); }
static Sequence* create(M m1, M m2, M m3, M m4, M m5, M m6, M m7, M m8, M m9, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, m5, m6, m7, m8, m9, NULL); }
static Sequence* create(M m1, M m2, M m3, M m4, M m5, M m6, M m7, M m8, M m9, M m10, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, NULL); }
// On WP8 for variable argument lists longer than 10 items, use the other create functions or variadicCreate with NULL as the last argument
// 在WP8中，可变参数的长度大于10时，使用一个其他的创建函数或者variadicCreate创建一个NUll对象作为最后的参数
static Sequence* variadicCreate(FiniteTimeAction* item, ...);
#else
static Sequence* create(FiniteTimeAction *action1, ...) CC_REQUIRES_NULL_TERMINATION;
#endif
/** Helper constructor to create an array of sequenceable actions given an array.
* @code
* When this funtion bound to the js or lua,the input params changed
* in js :var create(var object1,var object2, ...)
* in lua :local create(local object1,local object2, ...)
* @endcode
*
* @param arrayOfActions An array of sequenceable actions.
* @return An autoreleased Sequence object.
*/
/// 创建一个序列动作
static Sequence* create(const Vector<FiniteTimeAction*>& arrayOfActions);
/** Helper constructor to create an array of sequence-able actions.
*
* @param action1 The first sequenceable action.
* @param args The va_list variable.
* @return An autoreleased Sequence object.
* @js NA
*/
/// 通过一个可变参数列表创建一个序列动作
static Sequence* createWithVariableList(FiniteTimeAction *action1, va_list args);
/** Creates the action.
* @param actionOne The first sequenceable action.
* @param actionTwo The second sequenceable action.
* @return An autoreleased Sequence object.
* @js NA
*/
/// 创建一个只有两个动作的序列动作
static Sequence* createWithTwoActions(FiniteTimeAction *actionOne, FiniteTimeAction *actionTwo);
//
// Overrides
//
virtual Sequence* clone() const override;
virtual Sequence* reverse() const override;
virtual void startWithTarget(Node *target) override;
virtual void stop(void) override;
/**
* @param t In seconds.
*/
virtual void update(float t) override;
CC_CONSTRUCTOR_ACCESS:
Sequence() {}
virtual ~Sequence(void);
/** initializes the action */
/// 初始化
bool initWithTwoActions(FiniteTimeAction *pActionOne, FiniteTimeAction *pActionTwo);
protected:
FiniteTimeAction *_actions[2];
float _split;
int _last;
private:
CC_DISALLOW_COPY_AND_ASSIGN(Sequence);
};
/** @class Repeat
* @brief Repeats an action a number of times.
* To repeat an action forever use the RepeatForever action.
*/
/// 重复动作
/// 重复一个动作几次
/// 如果要永远重复一个动作，使用RepeatForever动作
class CC_DLL Repeat : public ActionInterval
{
public:
/** Creates a Repeat action. Times is an unsigned integer between 1 and pow(2,30).
*
* @param action The action needs to repeat.
* @param times The repeat times.
* @return An autoreleased Repeat object.
*/
/// 创建一个重复动作
static Repeat* create(FiniteTimeAction *action, unsigned int times);
/** Sets the inner action.
*
* @param action The inner action.
*/
/// 设置重复动作的内部动作
inline void setInnerAction(FiniteTimeAction *action)
{
if (_innerAction != action)
{
CC_SAFE_RETAIN(action);
CC_SAFE_RELEASE(_innerAction);
_innerAction = action;
}
}
/** Gets the inner action.
*
* @return The inner action.
*/
/// 返回内部动作
inline FiniteTimeAction* getInnerAction()
{
return _innerAction;
}
//
// Overrides
//
virtual Repeat* clone() const override;
virtual Repeat* reverse() const override;
virtual void startWithTarget(Node *target) override;
virtual void stop(void) override;
/**
* @param dt In seconds.
*/
virtual void update(float dt) override;
virtual bool isDone(void) const override;
CC_CONSTRUCTOR_ACCESS:
Repeat() {}
virtual ~Repeat();
/** initializes a Repeat action. Times is an unsigned integer between 1 and pow(2,30) */
/// 初始化
bool initWithAction(FiniteTimeAction *pAction, unsigned int times);
protected:
unsigned int _times;
unsigned int _total;
float _nextDt;
bool _actionInstant;
/** Inner action */
FiniteTimeAction *_innerAction;
private:
CC_DISALLOW_COPY_AND_ASSIGN(Repeat);
};
/** @class RepeatForever
* @brief Repeats an action for ever.
To repeat the an action for a limited number of times use the Repeat action.
* @warning This action can't be Sequenceable because it is not an IntervalAction.
*/
/// 永久重复动作
class CC_DLL RepeatForever : public ActionInterval
{
public:
/** Creates the action.
*
* @param action The action need to repeat forever.
* @return An autoreleased RepeatForever object.
*/
/// 创建一个永久重复动作
static RepeatForever* create(ActionInterval *action);
/** Sets the inner action.
*
* @param action The inner action.
*/
inline void setInnerAction(ActionInterval *action)
{
if (_innerAction != action)
{
CC_SAFE_RELEASE(_innerAction);
_innerAction = action;
CC_SAFE_RETAIN(_innerAction);
}
}
/** Gets the inner action.
*
* @return The inner action.
*/
inline ActionInterval* getInnerAction()
{
return _innerAction;
}
//
// Overrides
//
virtual RepeatForever* clone() const override;
virtual RepeatForever* reverse(void) const override;
virtual void startWithTarget(Node* target) override;
/**
* @param dt In seconds.
*/
virtual void step(float dt) override;
virtual bool isDone(void) const override;
CC_CONSTRUCTOR_ACCESS:
RepeatForever()
: _innerAction(nullptr)
{}
virtual ~RepeatForever();
/** initializes the action */
/// 初始化
bool initWithAction(ActionInterval *action);
protected:
/** Inner action */
ActionInterval *_innerAction;
private:
CC_DISALLOW_COPY_AND_ASSIGN(RepeatForever);
};
/** @class Spawn
* @brief Spawn a new action immediately
*/
/// 同时执行动作
/// 这个动作，同样需要传入一个动作的数组，与序列动作不同的是，这个数组中的动作是同时执行的，没有先后之分，
/// 动作的执行时间，就是数组中执行时间最长的动作
class CC_DLL Spawn : public ActionInterval
{
public:
/** Helper constructor to create an array of spawned actions.
* @code
* When this funtion bound to the js or lua, the input params changed.
* in js :var create(var object1,var object2, ...)
* in lua :local create(local object1,local object2, ...)
* @endcode
*
* @return An autoreleased Spawn object.
*/
#if (CC_TARGET_PLATFORM == CC_PLATFORM_WP8) || (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
// WP8 in VS2012 does not support nullptr in variable args lists and variadic templates are also not supported.
typedef FiniteTimeAction* M;
static Spawn* create(M m1, std::nullptr_t listEnd) { return variadicCreate(m1, NULL); }
static Spawn* create(M m1, M m2, std::nullptr_t listEnd) { return variadicCreate(m1, m2, NULL); }
static Spawn* create(M m1, M m2, M m3, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, NULL); }
static Spawn* create(M m1, M m2, M m3, M m4, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, NULL); }
static Spawn* create(M m1, M m2, M m3, M m4, M m5, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, m5, NULL); }
static Spawn* create(M m1, M m2, M m3, M m4, M m5, M m6, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, m5, m6, NULL); }
static Spawn* create(M m1, M m2, M m3, M m4, M m5, M m6, M m7, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, m5, m6, m7, NULL); }
static Spawn* create(M m1, M m2, M m3, M m4, M m5, M m6, M m7, M m8, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, m5, m6, m7, m8, NULL); }
static Spawn* create(M m1, M m2, M m3, M m4, M m5, M m6, M m7, M m8, M m9, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, m5, m6, m7, m8, m9, NULL); }
static Spawn* create(M m1, M m2, M m3, M m4, M m5, M m6, M m7, M m8, M m9, M m10, std::nullptr_t listEnd) { return variadicCreate(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, NULL); }
// On WP8 for variable argument lists longer than 10 items, use the other create functions or createSpawn with NULL as the last argument.
static Spawn* variadicCreate(FiniteTimeAction* item, ...);
#else
static Spawn* create(FiniteTimeAction *action1, ...) CC_REQUIRES_NULL_TERMINATION;
#endif
/** Helper constructor to create an array of spawned actions.
*
* @param action1 The first sequenceable action.
* @param args The va_list variable.
* @return An autoreleased Spawn object.
* @js NA
*/
static Spawn* createWithVariableList(FiniteTimeAction *action1, va_list args);
/** Helper constructor to create an array of spawned actions given an array.
*
* @param arrayOfActions An array of spawned actions.
* @return An autoreleased Spawn object.
*/
static Spawn* create(const Vector<FiniteTimeAction*>& arrayOfActions);
/** Creates the Spawn action.
*
* @param action1 The first spawned action.
* @param action2 THe second spawned action.
* @return An autoreleased Spawn object.
* @js NA
*/
static Spawn* createWithTwoActions(FiniteTimeAction *action1, FiniteTimeAction *action2);
//
// Overrides
//
virtual Spawn* clone() const override;
virtual Spawn* reverse(void) const override;
virtual void startWithTarget(Node *target) override;
virtual void stop(void) override;
/**
* @param time In seconds.
*/
virtual void update(float time) override;
CC_CONSTRUCTOR_ACCESS:
Spawn() {}
virtual ~Spawn();
/** initializes the Spawn action with the 2 actions to spawn */
bool initWithTwoActions(FiniteTimeAction *action1, FiniteTimeAction *action2);
protected:
FiniteTimeAction *_one;
FiniteTimeAction *_two;
private:
CC_DISALLOW_COPY_AND_ASSIGN(Spawn);
};
/** @class RotateTo
* @brief Rotates a Node object to a certain angle by modifying it's rotation attribute.
The direction will be decided by the shortest angle.
*/
/// 旋转动作
/// 执行这个动作的节点将旋转一定的角度
/// RotateTo和RotateBy的区别：
/// TO：旋转的最后角度是基于节点原本的角度的，而不是，节点当前的角度
/// BY；基于的是节点当前的角度
class CC_DLL RotateTo : public ActionInterval
{
public:
/**
* Creates the action with separate rotation angles.
*
* @param duration Duration time, in seconds.
* @param dstAngleX In degreesCW.
* @param dstAngleY In degreesCW.
* @return An autoreleased RotateTo object.
*/
/// 创建一个旋转动作，分别设置X方向和Y方向的旋转角度
static RotateTo* create(float duration, float dstAngleX, float dstAngleY);
/**
* Creates the action.
*
* @param duration Duration time, in seconds.
* @param dstAngle In degreesCW.
* @return An autoreleased RotateTo object.
*/
/// 创建一个旋转动作，传入一个旋转角度
static RotateTo* create(float duration, float dstAngle);
/**
* Creates the action with 3D rotation angles.
* @param duration Duration time, in seconds.
* @param dstAngle3D A Vec3 angle.
* @return An autoreleased RotateTo object.
*/
/// 创建一个在三维坐标下的旋转动作
static RotateTo* create(float duration, const Vec3& dstAngle3D);
//
// Overrides
//
virtual RotateTo* clone() const override;
virtual RotateTo* reverse() const override;
virtual void startWithTarget(Node *target) override;
/**
* @param time In seconds.
*/
virtual void update(float time) override;
CC_CONSTRUCTOR_ACCESS:
RotateTo();
virtual ~RotateTo() {}
/**
* initializes the action
* @param duration in seconds
* @param dstAngleX in degreesCW
* @param dstAngleY in degreesCW
*/
/// 初始化旋转动作
bool initWithDuration(float duration, float dstAngleX, float dstAngleY);
/**
* initializes the action
* @param duration in seconds
*/
/// 初始化旋转动作
bool initWithDuration(float duration, const Vec3& dstAngle3D);
/**
* calculates the start and diff angles
* @param dstAngle in degreesCW
*/
/// 计算开始和相差的角度
void calculateAngles(float &startAngle, float &diffAngle, float dstAngle);
protected:
bool _is3D;
Vec3 _dstAngle;
Vec3 _startAngle;
Vec3 _diffAngle;
private:
CC_DISALLOW_COPY_AND_ASSIGN(RotateTo);
};
/** @class RotateBy
* @brief Rotates a Node object clockwise a number of degrees by modifying it's rotation attribute.
*/
/// 旋转动作
class CC_DLL RotateBy : public ActionInterval
{
public:
/**
* Creates the action.
*
* @param duration Duration time, in seconds.
* @param deltaAngle In degreesCW.
* @return An autoreleased RotateBy object.
*/
/// 创建一个旋转动作
static RotateBy* create(float duration, float deltaAngle);
/**
* Creates the action with separate rotation angles.
*
* @param duration Duration time, in seconds.
* @param deltaAngleZ_X In degreesCW.
* @param deltaAngleZ_Y In degreesCW.
* @return An autoreleased RotateBy object.
* @warning The physics body contained in Node doesn't support rotate with different x and y angle.
*/
static RotateBy* create(float duration, float deltaAngleZ_X, float deltaAngleZ_Y);
/** Creates the action with 3D rotation angles.
*
* @param duration Duration time, in seconds.
* @param deltaAngle3D A Vec3 angle.
* @return An autoreleased RotateBy object.
*/
static RotateBy* create(float duration, const Vec3& deltaAngle3D);
//
// Override
//
virtual RotateBy* clone() const override;
virtual RotateBy* reverse(void) const override;
virtual void startWithTarget(Node *target) override;
/**
* @param time In seconds.
*/
virtual void update(float time) override;
CC_CONSTRUCTOR_ACCESS:
RotateBy();
virtual ~RotateBy() {}
/** initializes the action */
bool initWithDuration(float duration, float deltaAngle);
/**
* @warning The physics body contained in Node doesn't support rotate with different x and y angle.
* @param deltaAngleZ_X in degreesCW
* @param deltaAngleZ_Y in degreesCW
*/
bool initWithDuration(float duration, float deltaAngleZ_X, float deltaAngleZ_Y);
bool initWithDuration(float duration, const Vec3& deltaAngle3D);
protected:
bool _is3D;
Vec3 _deltaAngle;
Vec3 _startAngle;
private:
CC_DISALLOW_COPY_AND_ASSIGN(RotateBy);
};
/** @class MoveBy
* @brief Moves a Node object x,y pixels by modifying it's position attribute.
x and y are relative to the position of the object.
Several MoveBy actions can be concurrently called, and the resulting
movement will be the sum of individual movements.
@since v2.1beta2-custom
*/
/// 移动动作
/// 一个节点从一个点移动到另一个点，就用这个动作
/// MoveBy：传入的Vec2是节点在x,y上的变化值
/// MoveTo: 则是节点移动后的坐标
class CC_DLL MoveBy : public ActionInterval
{
public:
/**
* Creates the action.
*
* @param duration Duration time, in seconds.
* @param deltaPosition The delta distance in 2d, it's a Vec2 type.
* @return An autoreleased MoveBy object.
*/
/// 创建一个移动动作
static MoveBy* create(float duration, const Vec2& deltaPosition);
/**
* Creates the action.
*
* @param duration Duration time, in seconds.
* @param deltaPosition The delta distance in 3d, it's a Vec3 type.
* @return An autoreleased MoveBy object.
*/
/// 在三维坐标中创建一个移动动作
static MoveBy* create(float duration, const Vec3& deltaPosition);
//
// Overrides
//
virtual MoveBy* clone() const override;
virtual MoveBy* reverse(void) const override;
virtual void startWithTarget(Node *target) override;
/**
* @param time in seconds
*/
virtual void update(float time) override;
CC_CONSTRUCTOR_ACCESS:
MoveBy():_is3D(false) {}
virtual ~MoveBy() {}
/** initializes the action */
bool initWithDuration(float duration, const Vec2& deltaPosition);
bool initWithDuration(float duration, const Vec3& deltaPosition);
protected:
bool _is3D;
Vec3 _positionDelta;
Vec3 _startPosition;
Vec3 _previousPosition;
private:
CC_DISALLOW_COPY_AND_ASSIGN(MoveBy);
};
/** @class MoveTo
* @brief Moves a Node object to the position x,y. x and y are absolute coordinates by modifying it's position attribute.
Several MoveTo actions can be concurrently called, and the resulting
movement will be the sum of individual movements.
@since v2.1beta2-custom
*/
/// 创建一个移动动作
class CC_DLL MoveTo : public MoveBy
{
public:
/**
* Creates the action.
* @param duration Duration time, in seconds.
* @param position The destination position in 2d.
* @return An autoreleased MoveTo object.
*/
/// 创建一个移动动作
static MoveTo* create(float duration, const Vec2& position);
/**
* Creates the action.
* @param duration Duration time, in seconds.
* @param position The destination position in 3d.
* @return An autoreleased MoveTo object.
*/
static MoveTo* create(float duration, const Vec3& position);
//
// Overrides
//
virtual MoveTo* clone() const override;
virtual MoveTo* reverse() const override;
virtual void startWithTarget(Node *target) override;
CC_CONSTRUCTOR_ACCESS:
MoveTo() {}
virtual ~MoveTo() {}
/**
* initializes the action
* @param duration in seconds
*/
bool initWithDuration(float duration, const Vec2& position);
/**
* initializes the action
* @param duration in seconds
*/
bool initWithDuration(float duration, const Vec3& position);
protected:
Vec3 _endPosition;
private:
CC_DISALLOW_COPY_AND_ASSIGN(MoveTo);
};
/** @class SkewTo
* @brief Skews a Node object to given angles by modifying it's skewX and skewY attributes
@since v1.0
*/
/// 斜切动作
/// 需要设置X，Y方向的斜切值
class CC_DLL SkewTo : public ActionInterval
{
public:
/**
* Creates the action.
* @param t Duration time, in seconds.
* @param sx Skew x angle.
* @param sy Skew y angle.
* @return An autoreleased SkewTo object.
*/
/// 创建一个斜切动作
static SkewTo* create(float t, float sx, float sy);
//
// Overrides
//
virtual SkewTo* clone() const override;
virtual SkewTo* reverse(void) const override;
virtual void startWithTarget(Node *target) override;
/**
* @param time In seconds.
*/
virtual void update(float time) override;
CC_CONSTRUCTOR_ACCESS:
SkewTo();
virtual ~SkewTo() {}
/**
* @param t In seconds.
*/
bool initWithDuration(float t, float sx, float sy);
protected:
float _skewX;
float _skewY;
float _startSkewX;
float _startSkewY;
float _endSkewX;
float _endSkewY;
float _deltaX;
float _deltaY;
private:
CC_DISALLOW_COPY_AND_ASSIGN(SkewTo);
};
/** @class SkewBy
* @brief Skews a Node object by skewX and skewY degrees.
@since v1.0
*/
/// 斜切动作
class CC_DLL SkewBy : public SkewTo
{
public:
/**
* Creates the action.
* @param t Duration time, in seconds.
* @param deltaSkewX Skew x delta angle.
* @param deltaSkewY Skew y delta angle.
* @return An autoreleased SkewBy object.
*/
/// 创建一个斜切动作
static SkewBy* create(float t, float deltaSkewX, float deltaSkewY);
//
// Overrides
//
virtual void startWithTarget(Node *target) override;
virtual SkewBy* clone() const override;
virtual SkewBy* reverse(void) const override;
CC_CONSTRUCTOR_ACCESS:
SkewBy() {}
virtual ~SkewBy() {}
/**
* @param t In seconds.
*/
bool initWithDuration(float t, float sx, float sy);
private:
CC_DISALLOW_COPY_AND_ASSIGN(SkewBy);
};
/** @class JumpBy
* @brief Moves a Node object simulating a parabolic jump movement by modifying it's position attribute.
*/
/// 跳跃动作
/// JumpBy和JumpTo的区别：
/// 区别主要是最终的位置By：传入的坐标代表的是移动的位置，To：代表的是节点最终的位置
class CC_DLL JumpBy : public ActionInterval
{
public:
/**
* Creates the action.
* @param duration Duration time, in seconds.
* @param position The jumping distance.
* @param height The jumping height.
* @param jumps The jumping times.
* @return An autoreleased JumpBy object.
*/
/// 创建一个跳跃动作
static JumpBy* create(float duration, const Vec2& position, float height, int jumps);
//
// Overrides
//
virtual JumpBy* clone() const override;
virtual JumpBy* reverse(void) const override;
virtual void startWithTarget(Node *target) override;
/**
* @param time In seconds.
*/
virtual void update(float time) override;
CC_CONSTRUCTOR_ACCESS:
JumpBy() {}
virtual ~JumpBy() {}
/**
* initializes the action
* @param duration in seconds
*/
/// 初始化
bool initWithDuration(float duration, const Vec2& position, float height, int jumps);
protected:
Vec2 _startPosition;
Vec2 _delta;
float _height;
int _jumps;
Vec2 _previousPos;
private:
CC_DISALLOW_COPY_AND_ASSIGN(JumpBy);
};
/** @class JumpTo
* @brief Moves a Node object to a parabolic position simulating a jump movement by modifying it's position attribute.
*/
/// 跳跃动作
class CC_DLL JumpTo : public JumpBy
{
public:
/**
* Creates the action.
* @param duration Duration time, in seconds.
* @param position The jumping destination position.
* @param height The jumping height.
* @param jumps The jumping times.
* @return An autoreleased JumpTo object.
*/
/// 创建一个跳跃动作
static JumpTo* create(float duration, const Vec2& position, float height, int jumps);
//
// Override
//
virtual void startWithTarget(Node *target) override;
virtual JumpTo* clone() const override;
virtual JumpTo* reverse(void) const override;
CC_CONSTRUCTOR_ACCESS:
JumpTo() {}
virtual ~JumpTo() {}
/**
* initializes the action
* @param duration In seconds.
*/
/// 初始化
bool initWithDuration(float duration, const Vec2& position, float height, int jumps);
protected:
Vec2 _endPosition;
private:
CC_DISALLOW_COPY_AND_ASSIGN(JumpTo);
};
/** @struct Bezier configuration structure
*/
/// 贝塞尔曲线配置信息结构体
typedef struct _ccBezierConfig {
//! end position of the bezier
/// 贝塞尔曲线的结束坐标
Vec2 endPosition;
//! Bezier control point 1
/// 第一个控制点
Vec2 controlPoint_1;
//! Bezier control point 2
/// 第二个控制点
Vec2 controlPoint_2;
} ccBezierConfig;
/** @class BezierBy
* @brief An action that moves the target with a cubic Bezier curve by a certain distance.
*/
/// 贝塞尔曲线动作
/// 让一个节点按着贝塞尔曲线运动
class CC_DLL BezierBy : public ActionInterval
{
public:
/** Creates the action with a duration and a bezier configuration.
* @param t Duration time, in seconds.
* @param c Bezier config.
* @return An autoreleased BezierBy object.
* @code
* When this function bound to js or lua,the input params are changed.
* in js: var create(var t,var table)
* in lua: lcaol create(local t, local table)
* @endcode
*/
static BezierBy* create(float t, const ccBezierConfig& c);
//
// Overrides
//
virtual BezierBy* clone() const override;
virtual BezierBy* reverse(void) const override;
virtual void startWithTarget(Node *target) override;
/**
* @param time In seconds.
*/
virtual void update(float time) override;
CC_CONSTRUCTOR_ACCESS:
BezierBy() {}
virtual ~BezierBy() {}
/**
* initializes the action with a duration and a bezier configuration
* @param t in seconds
*/
bool initWithDuration(float t, const ccBezierConfig& c);
protected:
ccBezierConfig _config;
Vec2 _startPosition;
Vec2 _previousPosition;
private:
CC_DISALLOW_COPY_AND_ASSIGN(BezierBy);
};
/** @class BezierTo
* @brief An action that moves the target with a cubic Bezier curve to a destination point.
@since v0.8.2
*/
class CC_DLL BezierTo : public BezierBy
{
public:
/** Creates the action with a duration and a bezier configuration.
* @param t Duration time, in seconds.
* @param c Bezier config.
* @return An autoreleased BezierTo object.
* @code
* when this function bound to js or lua,the input params are changed
* in js: var create(var t,var table)
* in lua: lcaol create(local t, local table)
* @endcode
*/
static BezierTo* create(float t, const ccBezierConfig& c);
//
// Overrides
//
virtual void startWithTarget(Node *target) override;
virtual BezierTo* clone() const override;
virtual BezierTo* reverse(void) const override;
CC_CONSTRUCTOR_ACCESS:
BezierTo() {}
virtual ~BezierTo() {}
/**
* @param t In seconds.
*/
bool initWithDuration(float t, const ccBezierConfig &c);
protected:
ccBezierConfig _toConfig;
private:
CC_DISALLOW_COPY_AND_ASSIGN(BezierTo);
};
/** @class ScaleTo
@brief Scales a Node object to a zoom factor by modifying it's scale attribute.
@warning This action doesn't support "reverse".
@warning The physics body contained in Node doesn't support this action.
*/
/// 缩放动作
class CC_DLL ScaleTo : public ActionInterval
{
public:
/**
* Creates the action with the same scale factor for X and Y.
* @param duration Duration time, in seconds.
* @param s Scale factor of x and y.
* @return An autoreleased ScaleTo object.
*/
/// 创建一个缩放动作
static ScaleTo* create(float duration, float s);
/**
* Creates the action with and X factor and a Y factor.
* @param duration Duration time, in seconds.
* @param sx Scale factor of x.
* @param sy Scale factor of y.
* @return An autoreleased ScaleTo object.
*/
/// 创建一个缩放动作，分别设置x,y的缩放值
static ScaleTo* create(float duration, float sx, float sy);
/**
* Creates the action with X Y Z factor.
* @param duration Duration time, in seconds.
* @param sx Scale factor of x.
* @param sy Scale factor of y.
* @param sz Scale factor of z.
* @return An autoreleased ScaleTo object.
*/
/// 创建一个缩放动作，分别设置x,y,z的缩放值
static ScaleTo* create(float duration, float sx, float sy, float sz);
//
// Overrides
//
virtual ScaleTo* clone() const override;
virtual ScaleTo* reverse(void) const override;
virtual void startWithTarget(Node *target) override;
/**
* @param time In seconds.
*/
virtual void update(float time) override;
CC_CONSTRUCTOR_ACCESS:
ScaleTo() {}
virtual ~ScaleTo() {}
/**
* initializes the action with the same scale factor for X and Y
* @param duration in seconds
*/
bool initWithDuration(float duration, float s);
/**
* initializes the action with and X factor and a Y factor
* @param duration in seconds
*/
bool initWithDuration(float duration, float sx, float sy);
/**
* initializes the action with X Y Z factor
* @param duration in seconds
*/
bool initWithDuration(float duration, float sx, float sy, float sz);
protected:
float _scaleX;
float _scaleY;
float _scaleZ;
float _startScaleX;
float _startScaleY;
float _startScaleZ;
float _endScaleX;
float _endScaleY;
float _endScaleZ;
float _deltaX;
float _deltaY;
float _deltaZ;
private:
CC_DISALLOW_COPY_AND_ASSIGN(ScaleTo);
};
/** @class ScaleBy
* @brief Scales a Node object a zoom factor by modifying it's scale attribute.
@warning The physics body contained in Node doesn't support this action.
*/
/// 缩放动作
class CC_DLL ScaleBy : public ScaleTo
{
public:
/**
* Creates the action with the same scale factor for X and Y.
* @param duration Duration time, in seconds.
* @param s Scale factor of x and y.
* @return An autoreleased ScaleBy object.
*/
/// 创建一个缩放动作，设置缩放值
static ScaleBy* create(float duration, float s);
/**
* Creates the action with and X factor and a Y factor.
* @param duration Duration time, in seconds.
* @param sx Scale factor of x.
* @param sy Scale factor of y.
* @return An autoreleased ScaleBy object.
*/
/// 创建一个缩放动作，设置x,y的缩放值
static ScaleBy* create(float duration, float sx, float sy);
/**
* Creates the action with X Y Z factor.
* @param duration Duration time, in seconds.
* @param sx Scale factor of x.
* @param sy Scale factor of y.
* @param sz Scale factor of z.
* @return An autoreleased ScaleBy object.
*/
/// 创建一个缩放动作，设置，x,y,z 的缩放值
static ScaleBy* create(float duration, float sx, float sy, float sz);
//
// Overrides
//
virtual void startWithTarget(Node *target) override;
virtual ScaleBy* clone() const override;
virtual ScaleBy* reverse(void) const override;
CC_CONSTRUCTOR_ACCESS:
ScaleBy() {}
virtual ~ScaleBy() {}
private:
CC_DISALLOW_COPY_AND_ASSIGN(ScaleBy);
};
/** @class Blink
* @brief Blinks a Node object by modifying it's visible attribute.
*/
/// 闪烁动作
class CC_DLL Blink : public ActionInterval
{
public:
/**
* Creates the action.
* @param duration Duration time, in seconds.
* @param blinks Blink times.
* @return An autoreleased Blink object.
*/
/// 创建一个闪烁动作，传入持续时间和闪烁次数
static Blink* create(float duration, int blinks);
//
// Overrides
//
virtual Blink* clone() const override;
virtual Blink* reverse() const override;
/**
* @param time In seconds.
*/
virtual void update(float time) override;
virtual void startWithTarget(Node *target) override;
virtual void stop() override;
CC_CONSTRUCTOR_ACCESS:
Blink() {}
virtual ~Blink() {}
/**
* initializes the action
* @param duration in seconds
*/
bool initWithDuration(float duration, int blinks);
protected:
int _times;
bool _originalState;
private:
CC_DISALLOW_COPY_AND_ASSIGN(Blink);
};
/** @class FadeTo
* @brief Fades an object that implements the RGBAProtocol protocol. It modifies the opacity from the current value to a custom one.
@warning This action doesn't support "reverse"
*/
/// 渐隐动作，不支持reverse
/// 实际上，这个动作就是将节点的透明度设置的传入的值上，当然这个值是（0-255）之间的数
class CC_DLL FadeTo : public ActionInterval
{
public:
/**
* Creates an action with duration and opacity.
* @param duration Duration time, in seconds.
* @param opacity A certain opacity, the range is from 0 to 255.
* @return An autoreleased FadeTo object.
*/
/// 创建一个渐隐动作，传入持续时间和透明度
static FadeTo* create(float duration, GLubyte opacity);
//
// Overrides
//
virtual FadeTo* clone() const override;
virtual FadeTo* reverse(void) const override;
virtual void startWithTarget(Node *target) override;
/**
* @param time In seconds.
*/
virtual void update(float time) override;
CC_CONSTRUCTOR_ACCESS:
FadeTo() {}
virtual ~FadeTo() {}
/**
* initializes the action with duration and opacity
* @param duration in seconds
*/
bool initWithDuration(float duration, GLubyte opacity);
protected:
GLubyte _toOpacity;
GLubyte _fromOpacity;
friend class FadeOut;
friend class FadeIn;
private:
CC_DISALLOW_COPY_AND_ASSIGN(FadeTo);
};
/** @class FadeIn
* @brief Fades In an object that implements the RGBAProtocol protocol. It modifies the opacity from 0 to 255.
The "reverse" of this action is FadeOut
*/
/// 渐隐动作
/// 这个动作会在指定的时间内，将节点的透明度从0设置到255
class CC_DLL FadeIn : public FadeTo
{
public:
/**
* Creates the action.
* @param d Duration time, in seconds.
* @return An autoreleased FadeIn object.
*/
/// 创建一个渐隐动作
static FadeIn* create(float d);
//
// Overrides
//
virtual void startWithTarget(Node *target) override;
virtual FadeIn* clone() const override;
virtual FadeTo* reverse(void) const override;
/**
* @js NA
*/
void setReverseAction(FadeTo* ac);
CC_CONSTRUCTOR_ACCESS:
FadeIn():_reverseAction(nullptr) {}
virtual ~FadeIn() {}
private:
CC_DISALLOW_COPY_AND_ASSIGN(FadeIn);
FadeTo* _reverseAction;
};
/** @class FadeOut
* @brief Fades Out an object that implements the RGBAProtocol protocol. It modifies the opacity from 255 to 0.
The "reverse" of this action is FadeIn
*/
/// 渐现动作
/// 与渐隐动作相反，将一个节点的动作从255变化为0
class CC_DLL FadeOut : public FadeTo
{
public:
/**
* Creates the action.
* @param d Duration time, in seconds.
*/
static FadeOut* create(float d);
//
// Overrides
//
virtual void startWithTarget(Node *target) override;
virtual FadeOut* clone() const override;
virtual FadeTo* reverse(void) const override;
/**
* @js NA
*/
void setReverseAction(FadeTo* ac);
CC_CONSTRUCTOR_ACCESS:
FadeOut():_reverseAction(nullptr) {}
virtual ~FadeOut() {}
private:
CC_DISALLOW_COPY_AND_ASSIGN(FadeOut);
FadeTo* _reverseAction;
};
/** @class TintTo
* @brief Tints a Node that implements the NodeRGB protocol from current tint to a custom one.
@warning This action doesn't support "reverse"
@since v0.7.2
*/
/// 着色动作
/// 这个动作只支持NodeRGB（3.x的版本应该废弃这个类了，因为现在所有的节点都是RGBNode）
/// To，By的区别；
/// To：将节点的RGB值设置为传入的值
/// By：在节点RGB的基础上加上传入的值
class CC_DLL TintTo : public ActionInterval
{
public:
/**
* Creates an action with duration and color.
* @param duration Duration time, in seconds.
* @param red Red Color, from 0 to 255.
* @param green Green Color, from 0 to 255.
* @param blue Blue Color, from 0 to 255.
* @return An autoreleased TintTo object.
*/
/// 创建一个着色动作
static TintTo* create(float duration, GLubyte red, GLubyte green, GLubyte blue);
/**
* Creates an action with duration and color.
* @param duration Duration time, in seconds.
* @param color It's a Color3B type.
* @return An autoreleased TintTo object.
*/
/// 创建一个着色动作
static TintTo* create(float duration, const Color3B& color);
//
// Overrides
//
virtual TintTo* clone() const override;
virtual TintTo* reverse(void) const override;
virtual void startWithTarget(Node *target) override;
/**
* @param time In seconds.
*/
virtual void update(float time) override;
CC_CONSTRUCTOR_ACCESS:
TintTo() {}
virtual ~TintTo() {}
/** initializes the action with duration and color */
/// 初始化
bool initWithDuration(float duration, GLubyte red, GLubyte green, GLubyte blue);
protected:
Color3B _to;
Color3B _from;
private:
CC_DISALLOW_COPY_AND_ASSIGN(TintTo);
};
/** @class TintBy
@brief Tints a Node that implements the NodeRGB protocol from current tint to a custom one.
@since v0.7.2
*/
/// 着色动作
class CC_DLL TintBy : public ActionInterval
{
public:
/**
* Creates an action with duration and color.
* @param duration Duration time, in seconds.
* @param deltaRed Delta red color.
* @param deltaGreen Delta green color.
* @param deltaBlue Delta blue color.
* @return An autoreleased TintBy object.
*/
/// 创建一个着色动作
static TintBy* create(float duration, GLshort deltaRed, GLshort deltaGreen, GLshort deltaBlue);
//
// Overrides
//
virtual TintBy* clone() const override;
virtual TintBy* reverse() const override;
virtual void startWithTarget(Node *target) override;
/**
* @param time In seconds.
*/
virtual void update(float time) override;
CC_CONSTRUCTOR_ACCESS:
TintBy() {}
virtual ~TintBy() {}
/** initializes the action with duration and color */
/// 初始化
bool initWithDuration(float duration, GLshort deltaRed, GLshort deltaGreen, GLshort deltaBlue);
protected:
GLshort _deltaR;
GLshort _deltaG;
GLshort _deltaB;
GLshort _fromR;
GLshort _fromG;
GLshort _fromB;
private:
CC_DISALLOW_COPY_AND_ASSIGN(TintBy);
};
/** @class DelayTime
* @brief Delays the action a certain amount of seconds.
*/
/// 延迟动作
/// 延迟动作，就是什么都不干，等待一段时间
class CC_DLL DelayTime : public ActionInterval
{
public:
/**
* Creates the action.
* @param d Duration time, in seconds.
* @return An autoreleased DelayTime object.
*/
/// 创建一个延迟动作
static DelayTime* create(float d);
//
// Overrides
//
/**
* @param time In seconds.
*/
virtual void update(float time) override;
virtual DelayTime* reverse() const override;
virtual DelayTime* clone() const override;
CC_CONSTRUCTOR_ACCESS:
DelayTime() {}
virtual ~DelayTime() {}
private:
CC_DISALLOW_COPY_AND_ASSIGN(DelayTime);
};
/** @class ReverseTime
* @brief Executes an action in reverse order, from time=duration to time=0
@warning Use this action carefully. This action is not
sequenceable. Use it as the default "reversed" method
of your own actions, but using it outside the "reversed"
scope is not recommended.
*/
/// 反向动作
/// 这个动作试用与执行过一次reverse操作的动作。
/// action_0 ;action_1 = actiton_0->reverse() ;action_2 = ReverseTime::create(action_1) ;
class CC_DLL ReverseTime : public ActionInterval
{
public:
/** Creates the action.
*
* @param action a certain action.
* @return An autoreleased ReverseTime object.
*/
static ReverseTime* create(FiniteTimeAction *action);
//
// Overrides
//
virtual ReverseTime* reverse() const override;
virtual ReverseTime* clone() const override;
virtual void startWithTarget(Node *target) override;
virtual void stop(void) override;
/**
* @param time In seconds.
*/
virtual void update(float time) override;
CC_CONSTRUCTOR_ACCESS:
ReverseTime();
virtual ~ReverseTime(void);
/** initializes the action */
bool initWithAction(FiniteTimeAction *action);
protected:
FiniteTimeAction *_other;
private:
CC_DISALLOW_COPY_AND_ASSIGN(ReverseTime);
};
class Texture2D;
/** @class Animate
* @brief Animates a sprite given the name of an Animation.
*/
/// 动画动作，用过播放一段动画（帧动画就是用这个动作播放的）
class CC_DLL Animate : public ActionInterval
{
public:
/** Creates the action with an Animation and will restore the original frame when the animation is over.
*
* @param animation A certain animation.
* @return An autoreleased Animate object.
*/
/// 创建一个动画动作
static Animate* create(Animation *animation);
/** Sets the Animation object to be animated
*
* @param animation certain animation.
*/
/// 给动作设置动画
void setAnimation( Animation* animation );
/** returns the Animation object that is being animated
*
* @return Gets the animation object that is being animated.
*/
/// 返回动作的动画
Animation* getAnimation() { return _animation; }
const Animation* getAnimation() const { return _animation; }
//
// Overrides
//
virtual Animate* clone() const override;
virtual Animate* reverse() const override;
virtual void startWithTarget(Node *target) override;
virtual void stop(void) override;
/**
* @param t In seconds.
*/
virtual void update(float t) override;
CC_CONSTRUCTOR_ACCESS:
Animate();
virtual ~Animate();
/** initializes the action with an Animation and will restore the original frame when the animation is over */
/// 初始化动作
bool initWithAnimation(Animation *animation);
protected:
std::vector<float>* _splitTimes;
int _nextFrame;
SpriteFrame* _origFrame;
unsigned int _executedLoops;
Animation* _animation;
EventCustom* _frameDisplayedEvent;
AnimationFrame::DisplayedEventInfo _frameDisplayedEventInfo;
private:
CC_DISALLOW_COPY_AND_ASSIGN(Animate);
};
/** @class TargetedAction
* @brief Overrides the target of an action so that it always runs on the target
* specified at action creation rather than the one specified by runAction.
*/
/// 定向动作
/// 这个动作将执行另一个节点的指定动作
/// 也就是说，让传入的节点执行传入动作
class CC_DLL TargetedAction : public ActionInterval
{
public:
/** Create an action with the specified action and forced target.
*
* @param target The target needs to override.
* @param action The action needs to override.
* @return An autoreleased TargetedAction object.
*/
/// 创建一个定向动作
static TargetedAction* create(Node* target, FiniteTimeAction* action);
/** Sets the target that the action will be forced to run with.
*
* @param forcedTarget The target that the action will be forced to run with.
*/
/// 设置执行动作的节点
void setForcedTarget(Node* forcedTarget);
/** returns the target that the action is forced to run with.
*
* @return The target that the action is forced to run with.
*/
/// 返回执行动作的节点
Node* getForcedTarget() { return _forcedTarget; }
const Node* getForcedTarget() const { return _forcedTarget; }
//
// Overrides
//
virtual TargetedAction* clone() const override;
virtual TargetedAction* reverse() const override;
virtual void startWithTarget(Node *target) override;
virtual void stop(void) override;
/**
* @param time In seconds.
*/
virtual void update(float time) override;
CC_CONSTRUCTOR_ACCESS:
TargetedAction();
virtual ~TargetedAction();
/** Init an action with the specified action and forced target */
bool initWithTarget(Node* target, FiniteTimeAction* action);
protected:
FiniteTimeAction* _action;
Node* _forcedTarget;
private:
CC_DISALLOW_COPY_AND_ASSIGN(TargetedAction);
};
// end of actions group
/// @}
75
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
