text: /****************************************************************************
  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;
  
  protected:
      Speed();
      virtual ~Speed(void);
      /** initializes the action */
      bool initWithAction(ActionInterval *action, float speed);
  
      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;
  
  protected:
      /**
       * @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);
  
      // 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
      Point _halfScreenSize;
      Point _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__
  