Example #1
0
 /// <summary>
 /// Intializes a new <see cref="Effects"/> object
 /// </summary>
 /// <param name="effect">a single effect to check for</param>
 public Effects(Effect effect)
 {
     CheckEffects = new EffectArray(effect);
 }
Example #2
0
 /// <summary>
 /// Intializes a new <see cref="Effects"/> object
 /// </summary>
 /// <param name="array">An array of effects to check for</param>
 public Effects(EffectArray array)
 {
     CheckEffects = array;
 }
Example #3
0
 /// <summary>
 /// Intializes a new <see cref="Effects"/> object
 /// </summary>
 /// <param name="effects">a list of effects to check for</param>
 public Effects(List <Effect> effects)
 {
     CheckEffects = new EffectArray(effects);
 }
Example #4
0
        public void Deserialize(Stream input)
        {
            this.Version = input.ReadValueU16(false);

            if (this.Version != 2)
            {
                throw new InvalidDataException("not version 2");
            }

            // Effects
            {
                this.Effects = new List <EffectArray>();
                short type = input.ReadValueS16(false);
                while (type != -1)
                {
                    short version = input.ReadValueS16(false);

                    if (type < 0 || type >= EffectTypes.Length || EffectTypes[type] == null)
                    {
                        throw new InvalidOperationException("invalid type " + type.ToString());
                    }

                    if (EffectTypes[type].GetInterface("IEffectFormat") == null)
                    {
                        throw new InvalidOperationException(EffectTypes[type].ToString() + " does not derive IEffectFormat");
                    }

                    EffectArray effects = new EffectArray();
                    effects.Type    = type;
                    effects.Version = version;
                    effects.Entries = new List <IEffectFormat>();

                    int count = input.ReadValueS32(false);
                    for (int i = 0; i < count; i++)
                    {
                        IEffectFormat instance = (IEffectFormat)Activator.CreateInstance(EffectTypes[type]);

                        if (version < instance.MinimumVersion || version > instance.MaximumVersion)
                        {
                            throw new InvalidOperationException("bad version " + version.ToString() + " for type " + instance.ToString());
                        }

                        instance.Deserialize(input, effects.Version);
                        effects.Entries.Add(instance);
                    }

                    this.Effects.Add(effects);

                    type = input.ReadValueS16(false);
                }
            }

            // Resources
            {
                this.Resources = new List <ResourceArray>();
                short type = input.ReadValueS16(false);
                while (type != -1)
                {
                    short version = input.ReadValueS16(false);

                    if (type < 0 || type >= ResourceTypes.Length || ResourceTypes[type] == null)
                    {
                        throw new InvalidOperationException("invalid resource " + type.ToString());
                    }

                    if (ResourceTypes[type].GetInterface("IEffectFormat") == null)
                    {
                        throw new InvalidOperationException(ResourceTypes[type].ToString() + " does not derive IEffectFormat");
                    }

                    ResourceArray resources = new ResourceArray();
                    resources.Type    = type;
                    resources.Version = version;
                    resources.Entries = new List <IEffectFormat>();

                    int count = input.ReadValueS32(false);
                    for (int i = 0; i < count; i++)
                    {
                        IEffectFormat instance = (IEffectFormat)Activator.CreateInstance(ResourceTypes[type]);

                        if (version < instance.MinimumVersion || version > instance.MaximumVersion)
                        {
                            throw new InvalidOperationException("bad version " + version.ToString() + " for resource " + instance.ToString());
                        }

                        instance.Deserialize(input, resources.Version);
                        resources.Entries.Add(instance);
                    }

                    this.Resources.Add(resources);

                    type = input.ReadValueS16(false);
                }
            }

            // Visual effects
            {
                short version = input.ReadValueS16(false);

                this.VisualEffects         = new VisualEffectArray();
                this.VisualEffects.Version = version;
                this.VisualEffects.Entries = new List <IEffectFormat>();

                int count = input.ReadValueS32(false);
                for (int i = 0; i < count; i++)
                {
                    Effects.VisualEffect visualEffect = new Effects.VisualEffect();
                    visualEffect.Deserialize(input, version);
                    this.VisualEffects.Entries.Add(visualEffect);
                }
            }

            // ???
            {
                int unk = input.ReadValueS32(false);
                while (unk != -1)
                {
                    throw new NotImplementedException();
                    //unk = input.ReadS32(false);
                }
            }

            this.EffectNames = new Dictionary <int, string>();

            int id = input.ReadValueS32(false);

            while (id != -1)
            {
                this.EffectNames.Add(id, input.ReadStringASCIIZ());
                id = input.ReadValueS32(false);
            }

            throw new NotImplementedException();
        }