mirror of https://github.com/axmolengine/axmol.git
300 lines
8.3 KiB
C++
300 lines
8.3 KiB
C++
/****************************************************************************
|
|
Copyright (c) 2008-2010 Ricardo Quesada
|
|
Copyright (c) 2010-2012 cocos2d-x.org
|
|
Copyright (c) 2011 Zynga Inc.
|
|
Copyright (c) 2013-2014 Chukong Technologies Inc.
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
****************************************************************************/
|
|
|
|
#ifndef __ACTIONS_CCACTION_H__
|
|
#define __ACTIONS_CCACTION_H__
|
|
|
|
#include "CCRef.h"
|
|
#include "CCGeometry.h"
|
|
|
|
NS_CC_BEGIN
|
|
|
|
class Node;
|
|
/**
|
|
* @addtogroup actions
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
@brief Base class for Action objects.
|
|
*/
|
|
class CC_DLL Action : public Ref, public Clonable
|
|
{
|
|
public:
|
|
/// Default tag used for all the actions
|
|
static const int INVALID_TAG = -1;
|
|
/**
|
|
* @js NA
|
|
* @lua NA
|
|
*/
|
|
virtual std::string description() const;
|
|
|
|
/** returns a clone of action */
|
|
virtual Action* clone() const = 0;
|
|
|
|
/** returns a new action that performs the exactly the reverse action */
|
|
virtual Action* reverse() const = 0;
|
|
|
|
//! return true if the action has finished
|
|
virtual bool isDone() const;
|
|
|
|
//! called before the action start. It will also set the target.
|
|
virtual void startWithTarget(Node *target);
|
|
|
|
/**
|
|
called after the action has finished. It will set the 'target' to nil.
|
|
IMPORTANT: You should never call "[action stop]" manually. Instead, use: "target->stopAction(action);"
|
|
*/
|
|
virtual void stop();
|
|
|
|
//! called every frame with it's delta time. DON'T override unless you know what you are doing.
|
|
virtual void step(float dt);
|
|
|
|
/**
|
|
called once per frame. time a value between 0 and 1
|
|
|
|
For example:
|
|
- 0 means that the action just started
|
|
- 0.5 means that the action is in the middle
|
|
- 1 means that the action is over
|
|
*/
|
|
virtual void update(float time);
|
|
|
|
inline Node* getTarget() const { return _target; }
|
|
/** The action will modify the target properties. */
|
|
inline void setTarget(Node *target) { _target = target; }
|
|
|
|
inline Node* getOriginalTarget() const { return _originalTarget; }
|
|
/** Set the original target, since target can be nil.
|
|
Is the target that were used to run the action. Unless you are doing something complex, like ActionManager, you should NOT call this method.
|
|
The target is 'assigned', it is not 'retained'.
|
|
@since v0.8.2
|
|
*/
|
|
inline void setOriginalTarget(Node *originalTarget) { _originalTarget = originalTarget; }
|
|
|
|
inline int getTag() const { return _tag; }
|
|
inline void setTag(int tag) { _tag = tag; }
|
|
|
|
protected:
|
|
Action();
|
|
virtual ~Action();
|
|
|
|
Node *_originalTarget;
|
|
/** The "target".
|
|
The target will be set with the 'startWithTarget' method.
|
|
When the 'stop' method is called, target will be set to nil.
|
|
The target is 'assigned', it is not 'retained'.
|
|
*/
|
|
Node *_target;
|
|
/** The action tag. An identifier of the action */
|
|
int _tag;
|
|
|
|
private:
|
|
CC_DISALLOW_COPY_AND_ASSIGN(Action);
|
|
};
|
|
|
|
/**
|
|
@brief
|
|
Base class actions that do have a finite time duration.
|
|
Possible actions:
|
|
- An action with a duration of 0 seconds
|
|
- An action with a duration of 35.5 seconds
|
|
|
|
Infinite time actions are valid
|
|
*/
|
|
class CC_DLL FiniteTimeAction : public Action
|
|
{
|
|
public:
|
|
//! get duration in seconds of the action
|
|
inline float getDuration() const { return _duration; }
|
|
//! set duration in seconds of the action
|
|
inline void setDuration(float duration) { _duration = duration; }
|
|
|
|
//
|
|
// Overrides
|
|
//
|
|
virtual FiniteTimeAction* reverse() const override = 0;
|
|
virtual FiniteTimeAction* clone() const override = 0;
|
|
|
|
protected:
|
|
FiniteTimeAction()
|
|
: _duration(0)
|
|
{}
|
|
virtual ~FiniteTimeAction(){}
|
|
|
|
//! duration in seconds
|
|
float _duration;
|
|
|
|
private:
|
|
CC_DISALLOW_COPY_AND_ASSIGN(FiniteTimeAction);
|
|
};
|
|
|
|
class ActionInterval;
|
|
class RepeatForever;
|
|
|
|
/**
|
|
@brief Changes the speed of an action, making it take longer (speed>1)
|
|
or less (speed<1) time.
|
|
Useful to simulate 'slow motion' or 'fast forward' effect.
|
|
@warning This action can't be Sequenceable because it is not an IntervalAction
|
|
*/
|
|
class CC_DLL Speed : public Action
|
|
{
|
|
public:
|
|
/** create the action */
|
|
static Speed* create(ActionInterval* action, float speed);
|
|
|
|
inline float getSpeed(void) const { return _speed; }
|
|
/** alter the speed of the inner function in runtime */
|
|
inline void setSpeed(float speed) { _speed = speed; }
|
|
|
|
|
|
void setInnerAction(ActionInterval *action);
|
|
|
|
inline ActionInterval* getInnerAction() const { return _innerAction; }
|
|
|
|
//
|
|
// Override
|
|
//
|
|
virtual Speed* clone() const override;
|
|
virtual Speed* reverse() const override;
|
|
virtual void startWithTarget(Node* target) override;
|
|
virtual void stop() override;
|
|
virtual void step(float dt) override;
|
|
virtual bool isDone() const override;
|
|
|
|
CC_CONSTRUCTOR_ACCESS:
|
|
Speed();
|
|
virtual ~Speed(void);
|
|
/** initializes the action */
|
|
bool initWithAction(ActionInterval *action, float speed);
|
|
|
|
protected:
|
|
float _speed;
|
|
ActionInterval *_innerAction;
|
|
|
|
private:
|
|
CC_DISALLOW_COPY_AND_ASSIGN(Speed);
|
|
};
|
|
|
|
/**
|
|
@brief Follow is an action that "follows" a node.
|
|
|
|
Eg:
|
|
@code
|
|
layer->runAction(Follow::actionWithTarget(hero));
|
|
@endcode
|
|
|
|
Instead of using Camera as a "follower", use this action instead.
|
|
@since v0.99.2
|
|
*/
|
|
class CC_DLL Follow : public Action
|
|
{
|
|
public:
|
|
/**
|
|
* Creates the action with a set boundary or with no boundary.
|
|
*
|
|
* @param followedNode The node to be followed.
|
|
* @param rect The boundary. If \p rect is equal to Rect::ZERO, it'll work
|
|
* with no boundary.
|
|
*/
|
|
static Follow* create(Node *followedNode, const Rect& rect = Rect::ZERO);
|
|
|
|
inline bool isBoundarySet() const { return _boundarySet; }
|
|
/** alter behavior - turn on/off boundary */
|
|
inline void setBoudarySet(bool value) { _boundarySet = value; }
|
|
|
|
//
|
|
// Override
|
|
//
|
|
virtual Follow* clone() const override;
|
|
virtual Follow* reverse() const override;
|
|
virtual void step(float dt) override;
|
|
virtual bool isDone() const override;
|
|
virtual void stop() override;
|
|
|
|
CC_CONSTRUCTOR_ACCESS:
|
|
/**
|
|
* @js ctor
|
|
*/
|
|
Follow()
|
|
: _followedNode(nullptr)
|
|
, _boundarySet(false)
|
|
, _boundaryFullyCovered(false)
|
|
, _leftBoundary(0.0)
|
|
, _rightBoundary(0.0)
|
|
, _topBoundary(0.0)
|
|
, _bottomBoundary(0.0)
|
|
, _worldRect(Rect::ZERO)
|
|
{}
|
|
/**
|
|
* @js NA
|
|
* @lua NA
|
|
*/
|
|
virtual ~Follow();
|
|
|
|
/**
|
|
* Initializes the action with a set boundary or with no boundary.
|
|
*
|
|
* @param followedNode The node to be followed.
|
|
* @param rect The boundary. If \p rect is equal to Rect::ZERO, it'll work
|
|
* with no boundary.
|
|
*/
|
|
bool initWithTarget(Node *followedNode, const Rect& rect = Rect::ZERO);
|
|
|
|
protected:
|
|
// node to follow
|
|
Node *_followedNode;
|
|
|
|
// whether camera should be limited to certain area
|
|
bool _boundarySet;
|
|
|
|
// if screen size is bigger than the boundary - update not needed
|
|
bool _boundaryFullyCovered;
|
|
|
|
// fast access to the screen dimensions
|
|
Vector2 _halfScreenSize;
|
|
Vector2 _fullScreenSize;
|
|
|
|
// world boundaries
|
|
float _leftBoundary;
|
|
float _rightBoundary;
|
|
float _topBoundary;
|
|
float _bottomBoundary;
|
|
Rect _worldRect;
|
|
|
|
private:
|
|
CC_DISALLOW_COPY_AND_ASSIGN(Follow);
|
|
};
|
|
|
|
// end of actions group
|
|
/// @}
|
|
|
|
NS_CC_END
|
|
|
|
#endif // __ACTIONS_CCACTION_H__
|