Tried to title my post as best I could, but here goes.

I have 5 classes for various "effect" animation stuff that can be done to an animation (alpha change, color change, position change, rotation change, scale change). They are all the same aside from variable types. They all use an abstract class for methods that could be shared between them all along with methods that are override in the derived classes.

I have a class that is for handling all the animations of a game object called AnimationHandler. What it does is store all the effect animations (along with the sprite animations) for my game's objects and handling them. 

What I want to do is store all the effects into one dictionary that is then used to handle all changes to an animation for that object. I was wondering if it was possible to do or if it would be just easier to have 5 separate dictionaries to handle each effect separately?

The issue that I'm trying to figure out is how to access the variables that aren't in the abstract class.

Here is the sample code for my base class and a derived class:

```
abstract class EffectAnimation
{
    protected EffectInfo Info;
    public EffectInfo info
    {
        get
        { return Info; }
    }

    protected EffectType TypeOfEffect;
    public EffectType typeofeffect
    {
        get
        { return TypeOfEffect; }
    }

    public abstract void NewAnimation();
    public void Update(double time) 
    { 
        AnimationDone(time);
        if (!info.Done)
        {
            if (UtilityAnimation.ReadyForNextFrame(time, Info.FrameLength))
            {
                Info.NextFrameTime = time + Info.FrameLength;
                ChangeValue();
            }
        }
    }

    public void Start(double time) 
    {
        Info.StartTime = time;
        Info.NextFrameTime = time + Info.FrameLength;
    }

    public abstract void ChangeValue();
    public abstract void Clamp();
    protected abstract void AnimationDone(double time);
}

class AlphaAnimation : EffectAnimation
{
    private float Change;
    public float change
    {
        get
        { return Change; }
        set
        { Change = value; }
    }

    private float End;
    public float end
    {
        get
        { return End; }
        set
        { End = value; }
    }

    private float Total;
    public float total
    {
        get
        { return Total; }
        set
        { Total = value; }
    }

    public void NewAnimation(EffectInfo stuff, float starting, float ending, float partialtotal)
    {
        Total = starting + partialtotal;
        Info = stuff;
        End = ending;
        Info.Initialize();
        Change = UtilityAnimation.MakeFadeAmount(stuff.AnimationLength, starting, ending, stuff.FPS);
    }

    public void ChangeValue()
    { Total += Change; }

    private void Clamp()
    {
        if (Change > 0) // animation is positive
        {
            if (Total > End)
            {
                Total = End;
            }
        }
        else // animation is negative
        {
            if (Total < End)
            {
                Total = End;
            }
        }
    }

    private void AnimationDone(double time)
    {
        Clamp();
        if ((Total == End) && (time >= Info.DoneTime()))
        { Info.Done = true; }
    }
}

```