public static CCActionInterval actionWithDuration(float d)
        {
            CCActionInterval ret = new CCActionInterval();
            ret.initWithDuration(d);

            return ret;
        }

        public static CCRepeatForever actionWithAction(CCActionInterval action)
        {
            CCRepeatForever ret = new CCRepeatForever();
            ret.initWithAction(action);

            return ret;
        }

        public bool initWithAction(CCActionInterval action)
        {
            Debug.Assert(action != null);

            m_pInnerAction = action;
            return true;
        }

        protected bool InitWithAction(CCActionInterval action, float fRate)
        {
            Debug.Assert(action != null);

            m_pInnerAction = action;
            m_fSpeed = fRate;

            return true;
        }

 protected virtual bool InitWithAction(CCAction pAction, float duration)
 {
     if (base.InitWithDuration(duration))
     {
         m_fRate = 1.0f;
         m_pOther = pAction as CCActionInterval;
         return true;
     }
     return false;
 }

        /// <summary>
        /// initializes the action
        /// </summary>
        /// <param name="pAction"></param>
        /// <returns></returns>
        public bool initWithAction(CCActionInterval pAction)
        {
		    if (base.initWithDuration(pAction.duration))
		    {
			    m_pOther = pAction;
			    return true;
		    }
		    return false;
		
        }

	    /// <summary>
	    /// Initializes the action with the inner action and the period in radians (default is 0.3) 
	    /// </summary>
	    /// <param name="pAction"></param>
	    /// <param name="fPeriod"></param>
	    /// <returns></returns>
        public bool initWithAction(CCActionInterval pAction, float fPeriod) 
        { 
            if (base.initWithAction(pAction))
		    {
			    m_fPeriod = fPeriod;
			    return true;
		    }

		    return false;
        }

        /// <summary>
        /// Initializes the action with the inner action and the rate parameter
        /// </summary>
        /// <param name="pAction"></param>
        /// <param name="fRate"></param>
        /// <returns></returns>
        public bool initWithAction(CCActionInterval pAction, float fRate) 
        {
            if (base.initWithAction(pAction))
		    {
			    m_fRate = fRate;
			    return true;
		    }

		return false;
        }

        public static CCSpeed actionWithAction(CCActionInterval action, float fRate)
        {
            CCSpeed ret = new CCSpeed();

            if (ret != null && ret.initWithAction(action, fRate))
            {
                return ret;
            }

            return null;
        }

        /// <summary>
        ///  initializes the action with an inner action that has the amplitude property, and a duration time
        /// </summary>
        public bool initWithAction(CCAction pAction, float duration)
        {
            if (base.initWithDuration(duration))
            {
                m_fRate = 1.0f;
                m_pOther = pAction as CCActionInterval;

                return true;
            }

            return false;
        }

        /// <summary>
        /// Creates the action with the inner action and the rate parameter 
        /// </summary>
        /// <param name="pAction"></param>
        /// <param name="fRate"></param>
        /// <returns></returns>
        public static new CCEaseIn actionWithAction(CCActionInterval pAction, float fRate)
        {
            CCEaseIn pRet = new CCEaseIn();

            if (pRet != null)
            {
                if (pRet.initWithAction(pAction, fRate))
                {
                    //pRet.autorelease();
                }
                else
                {
                    //CC_SAFE_RELEASE_NULL(pRet);
                }
            }
            return pRet;
        }

        /// <summary>
        /// Creates the action with the inner action and the period in radians (default is 0.3)
        /// </summary>
        /// <param name="pAction"></param>
        /// <param name="fPeriod"></param>
        /// <returns></returns>
        public static new CCEaseElasticOut actionWithAction(CCActionInterval pAction, float fPeriod)
        {
            CCEaseElasticOut pRet = new CCEaseElasticOut();

            if (pRet != null)
            {
                if (pRet.initWithAction(pAction, fPeriod))
                {
                    //pRet.autorelease();
                }
                else
                {
                    //CC_SAFE_RELEASE_NULL(pRet);
                }
            }

            return pRet;
        }

        /// <summary>
        /// creates the action
        /// </summary>
        /// <param name="pAction"></param>
        /// <returns></returns>
        public new static CCEaseSineInOut actionWithAction(CCActionInterval pAction) 
        {
            CCEaseSineInOut pRet = new CCEaseSineInOut();

            if (pRet != null)
            {
                if (pRet.initWithAction(pAction))
                {
                    //pRet.autorelease();
                }
                else
                {
                    //CC_SAFE_RELEASE_NULL(pRet);
                }
            }

            return pRet; 
        }

        /// <summary>
        /// creates the action
        /// </summary>
        /// <param name="pAction"></param>
        /// <returns></returns>
        public static new CCEaseExponentialIn actionWithAction(CCActionInterval pAction)
        {
            CCEaseExponentialIn pRet = new CCEaseExponentialIn();

            if (pRet != null)
            {
                if (pRet.initWithAction(pAction))
                {
                    //pRet->autorelease();
                }
                else
                {
                    //CC_SAFE_RELEASE_NULL(pRet);
                }
            }

            return pRet;
        }

        public override CCObject copyWithZone(CCZone zone)
        {
            CCZone tmpZone = zone;
            CCActionInterval ret = null;
            if (tmpZone != null && tmpZone.m_pCopyObject != null)
            {
                ret = (CCActionInterval)(tmpZone.m_pCopyObject);
            }
            else
            {
                // action's base class , must be called using __super::copyWithZone(), after overriding from derived class
                Debug.Assert(false);

                ret = new CCActionInterval();
                tmpZone = new CCZone(ret);
            }

            base.copyWithZone(tmpZone);

            ret.initWithDuration(Duration);

            return ret;
        }

 CCFiniteTimeAction ICCTransitionEaseScene.easeActionWithAction(CCActionInterval action)
 {
     throw new NotImplementedException();
 }

 public static new CCEaseExponentialIn Create(CCActionInterval pAction)
 {
     var pRet = new CCEaseExponentialIn();
     pRet.InitWithAction(pAction);
     return pRet;
 }

 public virtual CCActionInterval easeActionWithAction(CCActionInterval action)
 {
     return CCEaseInOut.actionWithAction(action, 3.0f);
 }

 public virtual CCFiniteTimeAction easeActionWithAction(CCActionInterval action)
 {
     return action;
 }

 public CCFiniteTimeAction EaseAction(CCActionInterval action)
 {
     return CCEaseOut.Create(action, 2.0f);
 }