public Ongoing(Keyword keyword, EffectType effect_type, int modifier, int duration)
 {
     key = keyword;
     type = effect_type;
     mod = modifier;
     dur = duration;
 }

        internal static async Task<IVideoEffectDefinition> CreateEffectDefinitionAsync(EffectType effectType)
        {
            switch (effectType)
            {
                case EffectType.Lumia:
                    return new LumiaEffectDefinition(() =>
                    {
                        return new IFilter[]
                    {
                        new AntiqueFilter(),
                        new FlipFilter(FlipMode.Horizontal)
                    };
                    });

                case EffectType.ShaderNv12:
                    IBuffer shaderY = await PathIO.ReadBufferAsync("ms-appx:///Invert_093_NV12_Y.cso");
                    IBuffer shaderUV = await PathIO.ReadBufferAsync("ms-appx:///Invert_093_NV12_UV.cso");
                    return new ShaderEffectDefinitionNv12(shaderY, shaderUV);

                case EffectType.ShaderBgrx8:
                    IBuffer shader = await PathIO.ReadBufferAsync("ms-appx:///Invert_093_RGB32.cso");
                    return new ShaderEffectDefinitionBgrx8(shader);

                default:
                    throw new ArgumentException("Invalid effect type");
            }
        }

	//Should be changed to calculate life, this function would then be used for all cases in which health pools are changed
	public void CalculateHealth(GameObject aCause, float aValue, EffectType aHealthEffect = EffectType.loss) //GameObject dealing damage, Damage, DamageType
	{
		try
		{
			switch (aHealthEffect)
			{
				case EffectType.loss:
					if (m_Pools.Health > 0)
					{
						m_Pools.Health -= aValue;
						m_Actor.m_HUD.UpdatePools();
					}
					break;
				case EffectType.gain:
					m_Pools.Health += aValue;
					m_Actor.m_HUD.UpdatePools();
					break;
			}

			if (m_Pools.Health > 0)
			{
				return;
			}

			m_Pools.Health = 0;
			m_Actor.m_HUD.DisplayGameOver();
		}
		catch
		{
			Debug.Log(m_Actor.name + " Statistics HUD reference is NULL");
		}
	}

 public override void Read(PacketReader r)
 {
     EffectType = (EffectType)r.ReadByte();
     TargetId = r.ReadInt32();
     PosA =(Location) new Location().Read(r);
     PosB = (Location) new Location().Read(r);
     Color = ARGB.Read(r);
 }

 public void ReadPacket(IMinecraftStream stream)
 {
     Effect = (EffectType)stream.ReadInt32();
     X = stream.ReadInt32();
     Y = stream.ReadInt8();
     Z = stream.ReadInt32();
     Data = stream.ReadInt32();
 }

 public Effect(Characteristic target, int amount, EffectType type, int duration, DurationType durType)
 {
     Target = target;
     Amount = amount;
     Type = type;
     Duration = duration;
     DurType = durType;
 }

 // --- Constructors ---
 public StatEffect(EffectType pmType, string pmName, string pmDesc, StatEffectEvent pmEffectEvent, int pmTurnsLeft)
 {
     type=	pmType;
     name=	pmName;
     desc=	pmDesc;
     effectEvent=	pmEffectEvent;
     turnsLeft=	pmTurnsLeft;
 }

 public void AddStatusEffect(EffectType type)
 {
     StatusEffect effect = GetEffectFromEnum(type);
     if (effect == null)
         return;
     if(type == EffectType.HIT)
         ResetEffects();
     AddStatusEffect(effect);
 }

 private void Avatars_OnEffect(EffectType type, LLUUID sourceID, LLUUID targetID, 
     LLVector3d targetPos, float duration, LLUUID id)
 {
     if (ShowEffects)
         Console.WriteLine(
         "ViewerEffect [{0}]: SourceID: {1} TargetID: {2} TargetPos: {3} Duration: {4} ID: {5}",
         type, sourceID.ToString(), targetID.ToString(), targetPos, duration,
         id.ToString());
 }

		//----------------------------------------------------------------------
		//  Here, we are going to search the quadrant that it is ahead of the player, because
		//  he is running
		//----------------------------------------------------------------------
		public static bool FindAhead(
			PlayerMobile pm,
			Point3D centerPoint,
			ref Point3D spawnPoint,
			LandType landType,
			int distance,
			EffectType effectType,
			int effectHue
			)
		{
			Direction dir = (Direction)((int)pm.Direction & 0x0f);

			Point3D foundPoint = new Point3D();

			Tour tour = delegate( Map map, int x, int y )
			{
				if( Utility.RandomDouble() < .5 ) return false; // break it up a little.

				Point2D currentPoint = new Point2D( pm.Location.X + x, pm.Location.Y + y );

				if( FindSpawnTileInternal(
						pm,
						centerPoint,
						currentPoint,
						ref foundPoint,
						landType,
						effectType,
						effectHue
						)
					)
				{
					return true;
				}

				return false;
			};

			bool found = Search.Octant(
				pm.Map,
				dir,
				distance,
				SearchDirection.Inwards,
				tour
				);

			if( found )
			{
				spawnPoint.X = foundPoint.X;
				spawnPoint.Y = foundPoint.Y;
				spawnPoint.Z = foundPoint.Z;

				return true;
			}

			return false;
		}

 public void addEffect(EffectType pType, Vector2 pOrigin, float pAngle)
 {
     for (int i = 0; i < MAX_EFFECTS; i++)
     {
         if (!mAllEffects[i].isAlive())
         {
             mAllEffects[i].initialize(pType, pOrigin, ref mParticles, pAngle);
             break;
         }
     }
 }

 /// <summary>
 /// Basiskonstruktor.
 /// </summary>
 public SpriteEffect()
 {
     elapsedTime = 0;
     CurrentSprite = Vector2.Zero;
     Size = Vector2.Zero;
     SheetSize = Vector2.Zero;
     Offset = 0;
     ChangeSpeed = 0.0f;
     CicleDirection = SpriteCicleDirection.Left;
     SpriteType = EffectType.None;
 }

        /// <summary>
        /// Creates a new instance of Effect
        /// </summary>
        /// <param name="aDuration">The duration of the effect</param>
        public Effect(EffectType aEffectType, int aMagnitude, int aDuration = 1)
        {
            // Set the effect type.
            EffectType = aEffectType;

            // Set the duration of this effect.
            Duration = aDuration;

            // Set the magnitude of this effect.
            Magnitude = aMagnitude;
        }

		//----------------------------------------------------------------------
		//  Opposite of the above; we want the first spawn location closest to
		//  the center -- no closer than the initial distance
		//----------------------------------------------------------------------
		public static bool FindOutwards(
			PlayerMobile pm,
			Point3D centerPoint,
			ref Point3D spawnPoint,
			LandType landType,
			int distance,
			EffectType effectType,
			int effectHue
			)
		{
			return FindSpiral( pm, centerPoint, ref spawnPoint, landType, distance, false, effectType, effectHue );
		}

		public IList<IEffectSpriteInfo> GetEffectInfo(EffectType effectType, int effectID)
		{
			switch (effectType)
			{
				case EffectType.Potion: return ResolvePotionEffect((HardCodedPotionEffect)effectID);
				case EffectType.Spell: return ResolveSpellEffect((HardCodedSpellGraphic)effectID);
				case EffectType.WarpOriginal:
				case EffectType.WarpDestination: return GetWarpEffect(effectType);
				case EffectType.WaterSplashies: return GetWaterEffect();
				default: throw new ArgumentOutOfRangeException("effectType", effectType, null);
			}
		}

    //
    //-- Send Message Calls
    //     This section is for the MESSAGES such as the ones described in the
    //     test instructions.
    //

    public static bool SendAffectMessage( InstanceID recipient, EffectType type, int intensity, double time = -1.0d )
    {
        Entity targetEntity = null;

        if( s_GameEntities.TryGetValue( target, out targetEntity ) )
        {
            targetEntity.Affect( type, intensity );
            return true;
        }

        return false;
    }

		public IList<SoundEffectInstance> GetSoundEffectsForEffect(EffectType type, int id)
		{
			switch (type)
			{
				case EffectType.Potion: return GetPotionSoundEffect(id);
				case EffectType.Spell: return GetSpellSoundEffect(id);
				case EffectType.WarpOriginal:
				case EffectType.WarpDestination: return GetWarpSoundEffect(type);
				case EffectType.WaterSplashies: return GetWaterSoundEffect();
				default: throw new ArgumentOutOfRangeException("type", type, null);
			}
		}

		internal EffectAudio(EffectType eType)
            : base(eType)
        {
			try
			{
				aChannels = null; //комментарии в IAudio
			}
			catch
			{
				Fail();
				throw;
			}
		}

 /// <summary>
 /// Primary constructor for Magic class. For single-effect spells.
 /// </summary>
 /// <param name="name">Name of the Spell.</param>
 /// <param name="cost">Cost of the Spell</param>
 /// <param name="description">Detailed Description of the Spell. Should not include Flavor Text.</param>
 /// <param name="potency">Numerical modifier for primary effect of spell.</param>
 /// <param name="accuracy">Base accuracy of the spell.</param>
 /// <param name="spellmagicschooltype">School of magic the spell falls under.</param>
 /// <param name="spellelementtype">Elemental effect of the spell.</param>
 /// <param name="spelleffecttype">Main effect type of the spell.</param>
 public Magic(string name = "", int cost = 0, string description = "", int potency = 0, double accuracy = 0,
     MagicSchoolType spellmagicschooltype = MagicSchoolType.Black, ElementType spellelementtype = ElementType.Light,
     EffectType spelleffecttype = EffectType.Damage)
 {
     Name = name;
     Cost = cost;
     Description = description;
     Potency = potency;
     Accuracy = accuracy;
     SpellMagicSchoolType = spellmagicschooltype;
     SpellElementType = spellelementtype;
     SkillEffectType = spelleffecttype;
 }

        async Task CS_WP_MT_Basic(EffectType effectType)
        {
            StorageFile source = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Input/Car.mp4"));
            StorageFile destination = await KnownFolders.VideosLibrary.CreateFileAsync("CS_WP_MT_Basic" + effectType + ".mp4", CreationCollisionOption.ReplaceExisting);

            var definition = await Utils.CreateEffectDefinitionAsync(effectType);

            var transcoder = new MediaTranscoder();
            transcoder.AddVideoEffect(definition.ActivatableClassId, true, definition.Properties);

            PrepareTranscodeResult transcode = await transcoder.PrepareFileTranscodeAsync(source, destination, MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Qvga));
            await transcode.TranscodeAsync();
        }