     {
         super.playReversed = value;
         
-        if (animation)
+        if (value && animation)
             animation.reverse();
         
         reverseAnimation = value;

            return;
        }
            
        isStyleMap = new Array(animationProperties.length);
        
        // These two temporary arrays will hold the values passed into the
        // Animation to be interpolated between during the animation. The order
        // of the values in these arrays must match the order of the property
        // names in the animationProperties array, as we will assume during update
        // events that the interpolated values in the array are in that same order.
        var fromVals:Array = [];
        var toVals:Array = [];
        for (var i:int = 0; i < animationProperties.length; ++i)
        {
            var holder:AnimationProperty = AnimationProperty(animationProperties[i]);
            var property:String = holder.property;
            var fromValue:Object = null;
            var toValue:Object = null;
            
            if (!property || (property == ""))
                throw new Error(resourceManager.getString("sparkEffects", "illegalPropValue", [property]));
                 
            setupStyleMapEntry(property);

            // For any invalid value, set the animating value to null
            // null is a trigger for finalizing the value later on
            fromValue = isValidValue(holder.valueFrom) ? holder.valueFrom : null;
            toValue = isValidValue(holder.valueTo) ? holder.valueTo : null;
            if (toValue === null && propertyChanges && 
                propertyChanges.end[property] !== undefined)
                toValue = propertyChanges.end[property];
            
            if (animationProperties.length > 1)
            {
                fromVals.push(fromValue);
                toVals.push(toValue);
            }
        }
    
        // TODO (chaase): avoid setting up animations on properties whose
        // from/to values are the same. Not worth the cycles, but also want
        // to avoid triggering any side effects when we're not actually changing
        // values    
        if (animationProperties.length > 1)
        {
            // Create the single Animation that will interpolate all properties
            // simultaneously by interpolating the elements of the 
            // from/toVals arrays
            animation = new Animation(fromVals, toVals, duration);
        }
        else
        {
            // Only one property; don't bother with the arrays
            animation = new Animation(fromValue, toValue, duration);
        }
        animation.addEventListener(AnimationEvent.ANIMATION_START, startHandler);
        animation.addEventListener(AnimationEvent.ANIMATION_UPDATE, updateHandler);
        animation.addEventListener(AnimationEvent.ANIMATION_REPEAT, repeatHandler);

            setupParentLayout(false);
            
        var anim:Animation = Animation(event.target);
        finalizeValues();

        // TODO (chaase): Consider putting AnimateInstance (and subclass's) 
        // play() functionality (the setup and playing of the Animation object)
        // into startEffect(), calling play() from here, and not overriding
