public void StopEffect(FC_GLOBAL_EFFECT effId)
    {
        List <LivingEffect> tobeRemoveEffects = new List <LivingEffect>();

        foreach (LivingEffect livingEff in _livingEffects)
        {
            if (livingEff._effID == (int)effId)
            {
                EffectInstance go = livingEff._effect;

                go.LifeTick = -1;
                go.DeadTick = -1;
                go.FinishEffect(true);
                go.myTransform.parent = _myRoot;
                go.gameObject.SetActive(false);
                tobeRemoveEffects.Add(livingEff);
            }
        }

        //remove living effects
        foreach (LivingEffect livingEff in tobeRemoveEffects)
        {
            _livingEffects.Remove(livingEff);
        }

        tobeRemoveEffects.Clear();
    }
Beispiel #2
0
    // Update is called once per frame
    protected virtual void Update()
    {
        List <LivingEffect> tobeRemoveEffects = new List <LivingEffect>();

        //update living objects, count down the life time
        foreach (LivingEffect livingEff in _livingEffects)
        {
            EffectInstance go = livingEff._effect;
            Assertion.Check(go != null);

            EffectInstance eff = go;
            if (eff != null)
            {
                if (eff.LifeTick > 0)
                {
                    //reduce eff life tick
                    eff.LifeTick -= Time.deltaTime;
                }
                else
                {
                    if (eff.DeadTick > 0)
                    {
                        eff.DeadTick -= Time.deltaTime;
                        eff.UpdatePointLight();
                    }
                    else
                    {
                        //recycle back to pool
                        eff.LifeTick = eff._lifeTime;
                        eff.DeadTick = eff._deadTime;
                        eff.FinishEffect(true);
                        eff.myTransform.parent = _myRoot;
                        go.gameObject.SetActive(false);

                        //remove it from living list
                        tobeRemoveEffects.Add(livingEff);
                    }
                }
            }
        }


        //remove living effects
        foreach (LivingEffect livingEff in tobeRemoveEffects)
        {
            _livingEffects.Remove(livingEff);
        }

        tobeRemoveEffects.Clear();
    }
    //Stop effect
    //stop all effects with id on this AV
    //time: stop and deactive left time
    public void StopEffect(FC_CHARACTER_EFFECT effId, AvatarController avatar, float deadTime)
    {
        if (effId == FC_CHARACTER_EFFECT.INVALID)
        {
            return;
        }

        //update living objects, count down the life time
        foreach (LivingEffect liveingEff in _livingEffects)
        {
            EffectInstance go = liveingEff._effect;
            Assertion.Check(go != null);

            //find avatar match
            if ((liveingEff._effID == (int)effId) && (liveingEff._avatar == avatar))
            {
                //stop it
                EffectInstance eff = go;
                if (eff != null)
                {
                    //stop effect and set life time
                    //we stop it but do not deactive it to get a "fade out" effect

                    /*
                     * if (eff._deadTime > 0)
                     *      eff.lifeTick = eff._deadTime;
                     * else
                     */

                    eff.LifeTick = -1;
                    if (deadTime > 0)
                    {
                        eff.DeadTick = deadTime;
                    }


                    eff.FinishEffect(false);
                }
            }
        }
    }
    public EffectInstance PlayEffect(FC_GLOBAL_EFFECT effId, Vector3 effPos, Quaternion effRot)
    {
        if (effId == FC_GLOBAL_EFFECT.INVALID)
        {
            return(null);
        }


        //get empty gameobject?
        List <EffectInstance> effList   = _allEffectArray[effId];
        EffectInstance        effResult = null;

        if (effList.Count > 0)
        {
            foreach (EffectInstance effInst in effList)
            {
                if (!effInst.gameObject.activeSelf)
                {
                    effResult = effInst;
                    break;
                }
            }
        }

        //no empty? create one
        if (effResult == null)
        {
            if (effList.Count == FCConst.GLOBAL_EFFECT_COUNT)
            {
                //already full, select a slot which is nearly dead
                effList.Sort(Compare);
                EffectInstance slot = effList[0];

                EffectInstance effTemp = slot;
                if (effTemp != null)
                {
                    //recycle back to pool
                    effTemp.LifeTick = effTemp._lifeTime;
                    effTemp.FinishEffect(true);
                    slot.gameObject.SetActive(false);
                    effResult = slot;
                }
            }
            else
            {
                //size is not full, add a new one
                GameObject ego = AddEffectToPool(effId);
                effResult = ego.GetComponent <EffectInstance>();
                Assertion.Check(effResult != null);
                effResult.global_effect_id = effId;
                effList.Add(effResult);
            }
        }

        //set enable and pos
        Assertion.Check(effResult != null);
        effResult.gameObject.SetActive(true);
        Transform effectRsltTransform = effResult.myTransform;

        effectRsltTransform.position = effPos;
        effectRsltTransform.rotation = effRot;

        //add to living list
        LivingEffect liveEff = new LivingEffect();

        liveEff._effect = effResult;
        liveEff._avatar = null;
        liveEff._effID  = (int)effId;

        _livingEffects.Add(liveEff);


        //get effect instanse and start effect
        EffectInstance eff = effResult;

        if (eff != null)
        {
            eff.LifeTick = eff._lifeTime;
            eff.DeadTick = eff._deadTime;
            eff.BeginEffect();
        }

        return(effResult);
    }