下次自动登录
现在的位置:
& 综合 & 正文
cocos2d-x节点（CCActionInterval.h)API
本文来自 ，引用必须注明出处！
cocos2d-x节点（CCActionInterval.h)API
温馨提醒：为了大家能更好学习，强烈推荐大家看看本人的这篇博客
//有时间间隔的 action，使用动画、闪烁、重复次数、按次序创建 action，贝塞尔曲线移动
///cocos2d-x-3.0alpha0/cocos2dx/actions
//有时间间隔的 action，使用动画、闪烁、重复次数、按次序 创建 action，贝塞尔曲线移动
#ifndef __ACTION_CCINTERVAL_ACTION_H__
#define __ACTION_CCINTERVAL_ACTION_H__
#include "base_nodes/CCNode.h"
#include "CCAction.h"
#include "CCProtocols.h"
#include "sprite_nodes/CCSpriteFrame.h"
#include "sprite_nodes/CCAnimation.h"
#include &vector&
NS_CC_BEGIN
* @addtogroup actions
@brief 一个间隔 action ，一个在确定周期内发生的 action
它有一个开始时间和一个结束时间. 结束时间参数，开始时间加上持续时间
这些 ActionInterval actions 有一些有趣的属性, 如:
- 他们可以正常运行（默认）
- 它们可以使用相反的方法逆转运行
- 它们可以随着运行时间的改变加速, AccelDeccel(加速减速) and Speed（快速） actions.
例如, 你可以模拟一个正常运行的乒乓球效果，然后再使用反向模式运行他
Action *pingPongAction = Sequence::actions(action, action-&reverse(), NULL);
class CC_DLL ActionInterval : public FiniteTimeAction
/** 从运行开始经过了多少秒. */
inline float getElapsed(void) { return _ }
/** 初始化一个
bool initWithDuration(float d);
//在 GridAction 里面扩展
void setAmplitudeRate(float amp);
float getAmplitudeRate(void);
// Overrides
virtual bool isDone(void)
virtual void step(float dt)
virtual void startWithTarget(Node *target)
virtual ActionInterval* reverse() const override = 0;
virtual ActionInterval *clone() const override = 0;
protected:
/** @brief 按照次序运行 actions, 一个接一个的
class CC_DLL Sequence : public ActionInterval
/** 辅助构造函数，用来创建一个按照次序运行的 action array（序列） */
static Sequence* create(FiniteTimeAction *pAction1, ...) CC_REQUIRES_NULL_TERMINATION;
/** 辅助构造函数，使用给丁的 array 创建一个按照次序运行的 action array（序列）
* 当这个函数绑定到 js or lua,输入参数会改变
create(var
object1,var
object2, ...)
* in lua :local create(local object1,local object2, ...)
* @endcode
static Sequence* create(Array *arrayOfActions);
/** 辅助构造函数，用来创建一个 sequence-able actions array */
static Sequence* createWithVariableList(FiniteTimeAction *pAction1, va_list args);
/** creates the action */
static Sequence* createWithTwoActions(FiniteTimeAction *pActionOne, FiniteTimeAction *pActionTwo);
virtual ~Sequence(void);
/** initializes the action */
bool initWithTwoActions(FiniteTimeAction *pActionOne, FiniteTimeAction *pActionTwo);
// Overrides
virtual Sequence* clone()
virtual Sequence* reverse()
virtual void startWithTarget(Node *target)
virtual void stop(void)
virtual void update(float t)
protected:
FiniteTimeAction *_actions[2];
/** @brief action 重复的次数.
* 如果一直使用下去使用 RepeatForever action.
class CC_DLL Repeat : public ActionInterval
/** 创建一个重复 action. Times 是一个 unsigned（无符号）整数，在 1 、 pow(2,30) 之间 */
static Repeat* create(FiniteTimeAction *pAction, unsigned int times);
virtual ~Repeat(void);
/** 创建一个重复 action. Times 是一个 unsigned（无符号）整数，在 1 、 pow(2,30) 之间 */
bool initWithAction(FiniteTimeAction *pAction, unsigned int times);
inline void setInnerAction(FiniteTimeAction *pAction)
if (_innerAction != pAction)
CC_SAFE_RETAIN(pAction);
CC_SAFE_RELEASE(_innerAction);
_innerAction = pA
inline FiniteTimeAction* getInnerAction()
return _innerA
// Overrides
virtual Repeat* clone()
virtual Repeat* reverse()
virtual void startWithTarget(Node *target)
virtual void stop(void)
virtual void update(float dt)
virtual bool isDone(void)
protected:
unsigned int _
unsigned int _
float _nextDt;
bool _actionI
/** Inner action */
FiniteTimeAction *_innerA
/** @brief 永远重复一个动作
在限定次数重复同一个 action
@warning 这个动作不能是 Sequenceable 因为它不是一个 IntervalAction
class CC_DLL RepeatForever : public ActionInterval
/** creates the action */
static RepeatForever* create(ActionInterval *pAction);
* @js ctor
RepeatForever()
: _innerAction(NULL)
virtual ~RepeatForever();
/** initializes the action */
bool initWithAction(ActionInterval *pAction);
inline void setInnerAction(ActionInterval *pAction)
if (_innerAction != pAction)
CC_SAFE_RELEASE(_innerAction);
_innerAction = pA
CC_SAFE_RETAIN(_innerAction);
inline ActionInterval* getInnerAction()
return _innerA
// Overrides
virtual RepeatForever* clone()
virtual RepeatForever* reverse(void)
virtual void startWithTarget(Node* target)
virtual void step(float dt)
virtual bool isDone(void)
protected:
/** Inner（内部） action */
ActionInterval *_innerA
/** @brief 立即产生一个新的 action
class CC_DLL Spawn : public ActionInterval
/** 辅助构造函数，用来创建一个 spawned actions 数组
* 当这个函数绑定到 js or lua,输入参数会改变
create(var
object1,var
object2, ...)
* in lua :local create(local object1,local object2, ...)
* @endcode
static Spawn* create(FiniteTimeAction *pAction1, ...) CC_REQUIRES_NULL_TERMINATION;
/** 辅助构造函数，用来创建一个 spawned actions
static Spawn* createWithVariableList(FiniteTimeAction *pAction1, va_list args);
/** 辅助构造函数，使用给定的 array 创建一个 spawned actions 数组 */
static Spawn* create(Array *arrayOfActions);
/** creates the Spawn action */
static Spawn* createWithTwoActions(FiniteTimeAction *pAction1, FiniteTimeAction *pAction2);
virtual ~Spawn(void);
/** 使用 两个 FiniteTimeAction 初始化 Spawn action */
bool initWithTwoActions(FiniteTimeAction *pAction1, FiniteTimeAction *pAction2);
// Overrides
virtual Spawn* clone()
virtual Spawn* reverse(void)
virtual void startWithTarget(Node *target)
virtual void stop(void)
virtual void update(float time)
protected:
FiniteTimeAction *_
FiniteTimeAction *_
/** @brief 通过修改旋转属性，把一个 Node 对象旋转特定的角度
方向将决定 shortest（最短）angle.
class CC_DLL RotateTo : public ActionInterval
/** 使用 单独的旋转角度 创建一个 action */
static RotateTo* create(float fDuration, float fDeltaAngleX, float fDeltaAngleY);
/** creates the action */
static RotateTo* create(float fDuration, float fDeltaAngle);
/** initializes the action */
bool initWithDuration(float fDuration, float fDeltaAngle);
bool initWithDuration(float fDuration, float fDeltaAngleX, float fDeltaAngleY);
// Overrides
virtual RotateTo* clone()
virtual RotateTo* reverse()
virtual void startWithTarget(Node *target)
virtual void update(float time)
protected:
float _dstAngleX;
float _startAngleX;
float _diffAngleX;
float _dstAngleY;
float _startAngleY;
float _diffAngleY;
/** @brief 顺时针旋转一个对象到特定的角度，特过这个你可以修改他的旋转属性
class CC_DLL RotateBy : public ActionInterval
/** creates the action */
static RotateBy* create(float fDuration, float fDeltaAngle);
/** initializes the action */
bool initWithDuration(float fDuration, float fDeltaAngle);
static RotateBy* create(float fDuration, float fDeltaAngleX, float fDeltaAngleY);
bool initWithDuration(float fDuration, float fDeltaAngleX, float fDeltaAngleY);
// Override
virtual RotateBy* clone()
virtual RotateBy* reverse(void)
virtual void startWithTarget(Node *target)
virtual void update(float time)
protected:
float _angleX;
float _startAngleX;
float _angleY;
float _startAngleY;
通过修改节点的位置，移动它们的 x，y 像素
x 、 y 相对于对象的位置.
可以同时调用几个 MoveBy action ，最后所得的运动将是所有单个运动的综合
@since v2.1beta2-custom
class CC_DLL MoveBy : public ActionInterval
/** creates the action */
static MoveBy* create(float duration, const Point& deltaPosition);
/** initializes the action */
bool initWithDuration(float duration, const Point& deltaPosition);
// Overrides
virtual MoveBy* clone()
virtual MoveBy* reverse(void)
virtual void startWithTarget(Node *target)
virtual void update(float time)
protected:
Point _positionD
Point _startP
Point _previousP
/** 移动节点对象的 x,y 位置，x,y 通过修改他的位置属性的绝对坐标。
可以同时调用几个 MoveBy action ，最后所得的运动将是所有单个运动的综合
@since v2.1beta2-custom
class CC_DLL MoveTo : public MoveBy
/** creates the action */
static MoveTo* create(float duration, const Point& position);
/** initializes the action */
bool initWithDuration(float duration, const Point& position);
// Overrides
virtual MoveTo* clone()
virtual void startWithTarget(Node *target)
protected:
Point _endP
/** 通过修改他的 skewX（倾斜）、skewY（倾斜）属性，倾斜节点对象到给定的角度
@since v1.0
class CC_DLL SkewTo : public ActionInterval
/** creates the action */
static SkewTo* create(float t, float sx, float sy);
bool initWithDuration(float t, float sx, float sy);
// Overrides
virtual SkewTo* clone()
virtual SkewTo* reverse(void)
virtual void startWithTarget(Node *target)
virtual void update(float time)
protected:
float _skewX;
float _skewY;
float _startSkewX;
float _startSkewY;
float _endSkewX;
float _endSkewY;
float _deltaX;
float _deltaY;
/** 通过 skewX（倾斜）、skewY（倾斜）角度 Skews（倾斜）Node 对象
@since v1.0
class CC_DLL SkewBy : public SkewTo
/** creates the action */
static SkewBy* create(float t, float deltaSkewX, float deltaSkewY);
bool initWithDuration(float t, float sx, float sy);
// Overrides
virtual void startWithTarget(Node *target)
virtual SkewBy* clone()
virtual SkewBy* reverse(void)
/** @brief 通过修改他的位置属性，移动节点对象模拟抛跳运动
class CC_DLL JumpBy : public ActionInterval
/** creates the action */
static JumpBy* create(float duration, const Point& position, float height, int jumps);
/** initializes the action */
bool initWithDuration(float duration, const Point& position, float height, int jumps);
// Overrides
virtual JumpBy* clone()
virtual JumpBy* reverse(void)
virtual void startWithTarget(Node *target)
virtual void update(float time)
protected:
_previousP
/** @brief 通过修改位他的置属性，移动Node对象到一个抛物线的位置模拟跳跃运动 */
class CC_DLL JumpTo : public JumpBy
/** creates the action */
static JumpTo* create(float duration, const Point& position, float height, int jumps);
// Override
virtual void startWithTarget(Node *target)
virtual JumpTo* clone()
virtual JumpTo* reverse(void)
/** Bezier（贝塞尔）配置结构
typedef struct _ccBezierConfig {
//! end position of the bezier
Point endP
//! Bezier control point 1
Point controlPoint_1;
//! Bezier control point 2
Point controlPoint_2;
} ccBezierC
/** @brief 使用 cubic Bezier curve（三次方贝塞尔曲线）把目标移动特定距离
class CC_DLL BezierBy : public ActionInterval
/** 使用 duration 、Bezier（贝塞尔）配置
创建一个 action
* 当这个函数绑定到 js or lua,输入参数会改变
* 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);
/** 使用 duration 、Bezier（贝塞尔）配置
初始化一个 action */
bool initWithDuration(float t, const ccBezierConfig& c);
// Overrides
virtual BezierBy* clone()
virtual BezierBy* reverse(void)
virtual void startWithTarget(Node *target)
virtual void update(float time)
protected:
ccBezierConfig _
Point _startP
Point _previousP
/** @brief 使用 cubic Bezier curve（三次方贝塞尔曲线）把目标移动到目标点
@since v0.8.2
class CC_DLL BezierTo : public BezierBy
/** 使用 duration 、Bezier（贝塞尔）配置
创建一个 action
* 当这个函数绑定到 js or lua,输入参数会改变
* 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);
bool initWithDuration(float t, const ccBezierConfig &c);
// Overrides
virtual void startWithTarget(Node *target)
virtual BezierTo* clone()
virtual BezierTo* reverse(void)
protected:
ccBezierConfig _toC
/** @brief 通过修改节点的 scale 属性，修改它的缩放系数
@warning 这个 action 不支持 "reverse"
class CC_DLL ScaleTo : public ActionInterval
/** 使用 X,y 上相同的比例因子 创建一个 action */
static ScaleTo* create(float duration, float s);
使用 X,y 上的比例因子 创建一个 action */
static ScaleTo* create(float duration, float sx, float sy);
/** 使用 X,y 上相同的比例因子 初始化一个 action */
bool initWithDuration(float duration, float s);
/** 使用 X,y 上的比例因子 初始化一个 action */
bool initWithDuration(float duration, float sx, float sy);
// Overrides
virtual ScaleTo* clone()
virtual ScaleTo* reverse(void)
virtual void startWithTarget(Node *target)
virtual void update(float time)
protected:
float _scaleX;
float _scaleY;
float _startScaleX;
float _startScaleY;
float _endScaleX;
float _endScaleY;
float _deltaX;
float _deltaY;
/** @brief 通过修改节点的 scale 属性，修改它的缩放系数.
class CC_DLL ScaleBy : public ScaleTo
/** 使用 X,y 上相同的比例因子 创建一个 action */
static ScaleBy* create(float duration, float s);
/** 使用 X,y 上的比例因子 创建一个 action */
static ScaleBy* create(float duration, float sx, float sy);
// Overrides
virtual void startWithTarget(Node *target)
virtual ScaleBy* clone()
virtual ScaleBy* reverse(void)
/** @brief 通过修改他的 visible（可见）属性，使一个节点对象 Blinks（闪烁）
class CC_DLL Blink : public ActionInterval
/** creates the action */
static Blink* create(float duration, int blinks);
/** initializes the action */
bool initWithDuration(float duration, int blinks);
// Overrides
virtual Blink* clone()
virtual Blink* reverse(void)
virtual void update(float time)
virtual void startWithTarget(Node *target)
virtual void stop()
protected:
bool _originalS
/** @brief 这个对象的 Fades 实现了 RGBAProtocol 协议. 它把对象的不透明度从 0 变化到 255
这个 action 和 FadeOut 相反
class CC_DLL FadeIn : public ActionInterval
/** creates the action */
static FadeIn* create(float d);
// Overrides
virtual void update(float time)
virtual FadeIn* clone()
virtual ActionInterval* reverse(void)
/** @brief 这个对象的 Fades 实现了 RGBAProtocol 协议. 它把对象的不透明度从 255 变化到 0
这个 action 和 FadeIn 相反
class CC_DLL FadeOut : public ActionInterval
/** creates the action */
static FadeOut* create(float d);
// Overrides
virtual void update(float time)
virtual FadeOut* clone()
virtual ActionInterval* reverse(void)
/** @brief 这个对象的 Fades 实现了 RGBAProtocol 协议. 它把对象的不透明度从当前值，变化到一个自定义的值.
@warning 这个 action 不支持 "reverse"（反向）
class CC_DLL FadeTo : public ActionInterval
/** 使用 duration 、 opacity（不透明度）创建一个 action
static FadeTo* create(float duration, GLubyte opacity);
/** 使用 duration 、 opacity（不透明度）初始化一个 action */
bool initWithDuration(float duration, GLubyte opacity);
// Overrides
virtual FadeTo* clone()
virtual FadeTo* reverse(void)
virtual void startWithTarget(Node *target)
virtual void update(float time)
protected:
GLubyte _toO
GLubyte _fromO
/** @brief Tints 实现了 NodeRGB 协议 当前节点是一个自定义的 tint 节点
@warning 这个 action 不支持 "reverse"（反向）
@since v0.7.2
class CC_DLL TintTo : public ActionInterval
/** 使用 duration 、 color 创建一个 action
static TintTo* create(float duration, GLubyte red, GLubyte green, GLubyte blue);
/** 使用 duration 、 color 初始化一个 action */
bool initWithDuration(float duration, GLubyte red, GLubyte green, GLubyte blue);
// Overrides
virtual TintTo* clone()
virtual TintTo* reverse(void)
virtual void startWithTarget(Node *target)
virtual void update(float time)
protected:
/** @brief Tints 实现了 NodeRGB 协议 当前节点是一个自定义的 tint 节点
@since v0.7.2
class CC_DLL TintBy : public ActionInterval
/** 使用 duration 、 color 创建一个 action */
static TintBy* create(float duration, GLshort deltaRed, GLshort deltaGreen, GLshort deltaBlue);
/** 使用 duration 、 color 初始化一个 action */
bool initWithDuration(float duration, GLshort deltaRed, GLshort deltaGreen, GLshort deltaBlue);
// Overrides
virtual TintBy* clone()
virtual TintBy* reverse()
virtual void startWithTarget(Node *target)
virtual void update(float time)
protected:
GLshort _deltaR;
GLshort _deltaG;
GLshort _deltaB;
GLshort _fromR;
GLshort _fromG;
GLshort _fromB;
/** @brief 延迟 一个确定的秒数 执行的 action
class CC_DLL DelayTime : public ActionInterval
/** creates the action */
static DelayTime* create(float d);
// Overrides
virtual void update(float time)
virtual DelayTime* reverse()
virtual DelayTime* clone()
/** @brief 以相反的顺序执行 action, 时间从 time=duration 变化到 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.
class CC_DLL ReverseTime : public ActionInterval
/** creates the action */
static ReverseTime* create(FiniteTimeAction *pAction);
virtual ~ReverseTime(void);
* @js ctor
ReverseTime();
/** initializes the action */
bool initWithAction(FiniteTimeAction *pAction);
// Overrides
virtual ReverseTime* reverse()
virtual ReverseTime* clone()
virtual void startWithTarget(Node *target)
virtual void stop(void)
virtual void update(float time)
protected:
FiniteTimeAction *_
class Texture2D;
/** @brief 给定动画名的动画精灵 */
class CC_DLL Animate : public ActionInterval
/** 使用 动画 创建一个动画结束时，将恢复原始的帧 */
static Animate* create(Animation *pAnimation);
* @js ctor
Animate();
virtual ~Animate();
/** 使用 动画 初始化一个动画结束时，将恢复原始的帧 */
bool initWithAnimation(Animation *pAnimation);
/** sets 动画对象的动画 */
void setAnimation( Animation* animation );
/** returns 动画对象的动画 */
Animation* getAnimation() { return _ }
const Animation* getAnimation() const { return _ }
// Overrides
virtual Animate* clone()
virtual Animate* reverse()
virtual void startWithTarget(Node *target)
virtual void stop(void)
virtual void update(float t)
protected:
std::vector&float&* _splitT
SpriteFrame*
unsigned int
_executedL
Animation*
/** 覆盖目标 action，所以它总是在目标上运行
* 指定的 action 被创建 而不是 runAction 制定的.
class CC_DLL TargetedAction : public ActionInterval
* @js ctor
TargetedAction();
virtual ~TargetedAction();
/** 使用 指定 action、forced（被迫）目标 创建一个 action */
static TargetedAction* create(Node* target, FiniteTimeAction* pAction);
/** 使用 指定 action、forced（被迫）目标 初始化一个 action
bool initWithTarget(Node* target, FiniteTimeAction* pAction);
target； action 会强制在目标上运行 */
void setForcedTarget(Node* forcedTarget);
/** returns target； action 会强制在目标上运行 */
Node* getForcedTarget() { return _forcedT }
const Node* getForcedTarget() const { return _forcedT }
// Overrides
virtual TargetedAction* clone()
virtual TargetedAction* reverse()
virtual void startWithTarget(Node *target)
virtual void stop(void)
virtual void update(float time)
FiniteTimeAction* _
Node* _forcedT
// end of actions group
#endif //__ACTION_CCINTERVAL_ACTION_H__
&&&&推荐文章:
【上篇】【下篇】为什么cocos-2dx 3.x 的PhysicsBody或者PhysicsShape不提供clone操作？
最近在写一个游戏Demo，有一个武器的工厂类，这个工厂类有个PhysicsBody/PhysicsShape的成员变量，准备当发射子弹的时候，利用这个成员变量创建相应的PhysicsBody。但是我发现PhysicsBody或者PhysicsShape都没有提供clone操作。那...想问下这样有什么设计上的考虑？另外就是有什么替代做法？}