public void HandleTranslatedtoHiddenPosition(Effects.Effect effect)
 {
     Visible = false;
     if (OnHidden != null) {
         OnHidden (this);
     }
 }

    public void TransitionState(OnEndFadeIn FadeIn,OnEndFadeOut FadeOut,_TransitionType TT)
    {
        switch (TT) {
        case _TransitionType.FadeOut_In:
            CurrentEffectObj = Instantiate (EffectObj)as GameObject;
            CurrentEffectScript = CurrentEffectObj.GetComponentInChildren<Effects> ();
            CurrentEffectScript.EndFadeOutEvent += () => {
                FadeOut();
                doFadeIn ();
            };

            CurrentEffectScript.EndFadeInEvent += () => {
                FadeIn ();
                Destroy (CurrentEffectObj);
            };

            doFadeOut ();
            break;

        case _TransitionType.No_Effect:
            FadeOut ();
            FadeIn ();
            break;
        }
    }

        public static void OutputEnum(Effects.Property enumProperty, Formatter output)
        {
            OutputVersionConditional(enumProperty.WinVer, output);

            output.WriteLine("[version(VERSION)]");
            output.WriteLine("typedef enum " + enumProperty.TypeNameIdl);
            output.WriteLine("{");
            output.Indent();

            for (int i = 0; i < enumProperty.EnumFields.FieldsList.Count; ++i)
            {
                var enumValue = enumProperty.EnumFields.FieldsList[i];
                if (i != (enumProperty.EnumFields.FieldsList.Count - 1))
                {
                    output.WriteLine(enumValue.Name + " = " + i.ToString() + ",");
                }
                else
                {
                    output.WriteLine(enumValue.Name + " = " + i.ToString());
                }
            }
            output.Unindent();
            output.WriteLine("} " + enumProperty.TypeNameIdl + ";");

            EndVersionConditional(enumProperty.WinVer, output);
        }

    public TargetSpell(JSONObject js) : base(js)
    {
        Id = (int)js.GetField(js.keys[0]).n;
		AreaId = (int)js.GetField("areaId").n;
		EffectsArea = new Effects(js.GetField("effectsAreaIds"));
		EffectsAreaCrit = new Effects(js.GetField("effectsAreaCritIds"));
		_rangeId = (int)js.GetField("rangeId").n;
    }

 // Use this for initialization
 void Start()
 {
     if (!player)
         player = GetComponent<Player> ();
     if(!rb)
         rb = GetComponent<Rigidbody>();
     effects = Player.Effects;
 }

 public DialogueConversationNode(bool waitUserInteraction)
 {
     dialogue = new List<ConversationLine>();
     nextNode = null;
     terminal = true;
     effects = new Effects();
     this.keepShowing = waitUserInteraction;
 }

	public virtual void Awake()
	{
		//DefaultPosition = transform.position;
		//DefaultRotation = transform.rotation;	
		Effects = new Effects();
		_renderer = GetComponent<Renderer>();
		if (_renderer == null)
			_renderer = GetComponentInChildren<Renderer>();
	}

    public SelfSpell(JSONObject js) : base(js)
    {
        Id = (int)js.GetField(js.keys[0]).n;
        AreaId = (int)js.GetField("areaId").n;
		EffectsArea = new Effects(js.GetField("effectsAreaIds"));
		EffectsAreaCrit = new Effects(js.GetField("effectsAreaCritIds"));
		_effects = new Effects(js.GetField("effectsIds"));
		_effectsCrit = new Effects(js.GetField("effectsCritIds"));
    }

 /**
  * Creates a new cutscene
  *
  * @param type
  *            The type of the scene
  * @param id
  *            The id of the scene
  */
 protected Cutscene(GeneralSceneSceneType type, string id)
     : base(type, id)
 {
     effects = new Effects();
     destinyX = int.MinValue;
     destinyY = int.MaxValue;
     transitionType = NextSceneEnumTransitionType.NO_TRANSITION;
     transitionTime = 0;
     next = GOBACK;
 }

 public SimplifierContext(bool inGlobalScope, bool keepFunctionNames, NameSupply nameSupply, Func<Expression, bool> isValue)
 {
     InGlobalScope = inGlobalScope;
     KeepFunctionNames = keepFunctionNames;
     NameSupply = nameSupply;
     subst = new Map<Identifier, Expression>();
     statements = null;
     contextEffects = Effects.Bottom;
     this.isValue = isValue;
 }

        public void AnimationExtention_should_serialize_property_opacity_animation()
        {
            Effects effect = new Effects();
            effect.Container.Add(new PropertyAnimation(PropertyAnimationType.Opacity));

            _writer.Setup(w => w.Write(It.IsAny<string>())).Verifiable();

            _objectWriter.Start().Serialize("effects", effect);

            _writer.Verify(w => w.Write("effects:{list:[{name:'property',properties:['opacity']}],openDuration:200,closeDuration:200}"));
        }

        public void AnimationExtention_should_serialize_slide_animation()
        {
            Effects effect = new Effects();
            effect.Container.Add(new SlideAnimation());

            _writer.Setup(w => w.Write(It.IsAny<string>())).Verifiable();

            _objectWriter.Start().Serialize("effects", effect);

            _writer.Verify(w => w.Write("effects:{list:[{name:'slide'}],openDuration:200,closeDuration:200}"));
        }

	void Start () 
    {
        int whatPower = Random.Range(0, itensNumber);

        switch (whatPower)
        {
            case 0: effect = Effects.SpeedPlus; this.GetComponent<SpriteRenderer>().sprite = powersSprites[0]; break;
            case 1: effect = Effects.SpeedMinus; this.GetComponent<SpriteRenderer>().sprite = powersSprites[1]; break;
            case 2: effect = Effects.AmmoPlus; this.GetComponent<SpriteRenderer>().sprite = powersSprites[2]; break;
            case 3: effect = Effects.AmmoMinus; this.GetComponent<SpriteRenderer>().sprite = powersSprites[3]; break;
        }
	}

    /**
     * Creates a new NextScene
     *
     * @param nextSceneId
     *            the id of the next scene
     */
    public NextScene(string nextSceneId)
    {
        this.nextSceneId = nextSceneId;

        destinyX = int.MinValue;
        destinyY = int.MinValue;
        conditions = new Conditions();
        effects = new Effects();
        postEffects = new Effects();
        transitionType = NextSceneEnumTransitionType.NO_TRANSITION;
        transitionTime = 0;
    }

 public static void Export(Effects effects)
 {
     SaveFileDialog sfd = new SaveFileDialog();
     sfd.Filter = WYZTracker.Core.Properties.Resources.FXFilter;
     if (sfd.ShowDialog() == DialogResult.OK)
     {
         XmlSerializer formatter = new XmlSerializer(typeof(Effects));
         Stream objFileStream = new FileStream(sfd.FileName, FileMode.Create, FileAccess.Write, FileShare.None);
         formatter.Serialize(objFileStream, effects);
         objFileStream.Close();
     }
 }

    public EffectHolder(Effects effects)
    {
        this.effects = new List<EffectHolderNode> ();

        if (effects != null && effects.getEffects().Count>0) {

            EffectHolderNode e = null;
            List<Condition> conditions = new List<Condition>();
            foreach (AbstractEffect effect in effects.getEffects()) {
                if (effect == null) {

                }
                this.effects.Add(new EffectHolderNode(effect));
            }
        }
    }

    public void FadeOut_FadeIn_Transition(OnEndFadeIn FadeIn,OnEndFadeOut Fadeout)
    {
        CurrentEffectObj = Instantiate (EffectObj)as GameObject;
        CurrentEffectScript = CurrentEffectObj.GetComponentInChildren<Effects> ();
        CurrentEffectScript.EndFadeOutEvent += () => {
            Fadeout ();
            doFadeIn ();
        };

        CurrentEffectScript.EndFadeInEvent += () => {
            FadeIn ();
            Destroy (CurrentEffectObj);
        };

        doFadeOut ();
    }

    public Timer(long time, Conditions init, Conditions end, Effects effect, Effects postEffect)
    {
        this.seconds = time;
        this.initCond = init;
        this.endCond = end;
        this.effect = effect;
        this.postEffect = postEffect;
        usesEndCondition = true;
        runsInLoop = true;
        multipleStarts = true;

        showTime = false;
        displayName = "timer";
        countDown = true;
        showWhenStopped = false;
    }

    public void Play(Effects effect)
    {
        GameObject go = null;
        if (effect == Effects.Attack)
            go = GameObject.Instantiate(attack, transform.position, Quaternion.identity) as GameObject;
        else if (effect == Effects.AdditionalAttack)
            go = GameObject.Instantiate(attackAdditional, transform.position, Quaternion.identity) as GameObject;
        else if (effect == Effects.BotAttack)
            go = GameObject.Instantiate(botAttack, transform.position, Quaternion.identity) as GameObject;
        else if (effect == Effects.PotionUse)
            go = GameObject.Instantiate(potion, transform.position, Quaternion.identity) as GameObject;
        else if (effect == Effects.PowerUpUse)
            go = GameObject.Instantiate(powerUp, transform.position, Quaternion.identity) as GameObject;

        go.transform.parent = this.transform;
        go.transform.localPosition = Vector3.zero;
    }

        /// <summary>
        /// Fill in a grid - used in terrain generation (for now) and anything that requires planar data
        /// </summary>
        /// <param name="width">Width in world units of grid</param>
        /// <param name="depth">Depth in world units of grid</param>
        /// <param name="m">Subdivisions in the x direction</param>
        /// <param name="n">Subdivisions in the z direction</param>
        /// <param name="verts">Output array of vertex positions</param>
        /// <param name="indices">Output array of index positions</param>
        public static void CreateGrid(float width, float depth, uint m, uint n, out Effects.BasicEffect.BasicEffectVertex[] verts, out uint[] indices)
        {
            var vertList = new List<Effects.BasicEffect.BasicEffectVertex>();
            var indexList = new List<uint>();

            var halfWidth = width * 0.5f;
            var halfDepth = depth * 0.5f;

            var dx = width / (n - 1);
            var dz = depth / (m - 1);

            var du = 1.0f / (n - 1);
            var dv = 1.0f / (m - 1);

            for (var i = 0; i < m; ++i)
            {
                var z = halfDepth - i * dz;
                for (var j = 0; j < n; ++j)
                {
                    var x = -halfWidth + j * dx;
                    //vertList.Add(new Vector3(x, 0.0f, z));
                    vertList.Add(new Effects.BasicEffect.BasicEffectVertex()
                    {
                        Pos = new Vector3(x, 0.0f, z),
                        TexCoord = new Vector2(j * du, i * dv)
                    });
                }
            }

            for (var i = 0u; i < m - 1; ++i)
            {
                for (var j = 0u; j < n - 1; ++j)
                {
                    indexList.Add(i * n + j);
                    indexList.Add(i * n + j + 1);
                    indexList.Add((i + 1) * n + j);

                    indexList.Add((i + 1) * n + j);
                    indexList.Add(i * n + j + 1);
                    indexList.Add((i + 1) * n + j + 1);
                }
            }

            verts = vertList.ToArray();
            indices = indexList.ToArray();
        }