GetCurrentAnimation() публичный Метод

public GetCurrentAnimation ( ) : exSpriteAnimState,
Результат exSpriteAnimState,
Пример #1
0
    public void SetGeneral(int gIdx, bool isFail)
    {
        GeneralInfo gInfo = Informations.Instance.GetGeneralInfo(gIdx);

        head.SetGeneralHead(gIdx);
        head.transform.GetChild(0).localScale = new Vector3(1, 1, 1);
        if (isFail)
        {
            head.transform.GetChild(0).GetComponent <exSprite>().color = new Color(0.25f, 0.25f, 0.25f, 1);
        }

        generalName.text = ZhongWen.Instance.GetGeneralName(gIdx);

        health.text  = gInfo.healthCur + "";
        mana.text    = gInfo.manaCur + "";
        soldier.text = (gInfo.soldierCur + gInfo.knightCur) + "";

        int idx = Misc.GetArmsIdx(gInfo.armsCur);

        arms.SetFrame(arms.GetCurrentAnimation().name, idx);
    }
Пример #2
0
    // ------------------------------------------------------------------
    // Desc:
    // ------------------------------------------------------------------

    int BackwardTriggerEvents(exSpriteAnimation _spAnim,
                              exSpriteAnimState _lastAnim,
                              int _index,
                              float _start,
                              float _end,
                              bool _includeStart)
    {
        int idx = _index;
        exSpriteAnimState curAnim = _spAnim.GetCurrentAnimation();

        for (int i = _index - 1; i >= 0; --i)
        {
            EventInfo ei = eventInfos[i];

            if (ei.time == _start && _includeStart == false)
            {
                idx = i;
                continue;
            }

            if (ei.time >= _end)
            {
                Trigger(_spAnim, ei);
                if (curAnim == null || _lastAnim != curAnim)
                {
                    return(-1);
                }
                idx = i;
            }
            else
            {
                break;
            }
        }
        return(idx);
    }
Пример #3
0
    // ------------------------------------------------------------------
    /// \param _spAnim send message to target _spAnim.gameObject
    /// \param _lastAnim last animation state
    /// \param _lastIndex last triggered event info index (-1 means from start)
    /// \param _start the start time in seconds
    /// \param _delta the delta time in seconds
    /// \param _wrapMode  the wrap mode
    /// \return return the last triggered event index
    /// Trigger events locate between the start and start+_delta time span
    // ------------------------------------------------------------------

    public int TriggerEvents(exSpriteAnimation _spAnim,
                             exSpriteAnimState _lastAnim,
                             int _lastIndex,
                             float _start,
                             float _delta,
                             WrapMode _wrapMode)
    {
        if (eventInfos.Count == 0)
        {
            return(-1);
        }
        if (_delta == 0.0f)
        {
            return(-1);
        }

        // WrapSeconds
        float t = WrapSeconds(_start, _wrapMode);

        // if we are the just start playing
        if (_lastIndex == -1)
        {
            return(ForwardTriggerEvents(_spAnim, _lastAnim, -1, t, t + _delta, true));
        }

        //
        if (_wrapMode == WrapMode.PingPong)
        {
            int cnt = (int)(_start / length);
            if (cnt % 2 == 1)
            {
                _delta = -_delta;
            }
        }

        // if we are play forward
        if (_delta > 0.0f)
        {
            if (t + _delta > length)
            {
                if (_wrapMode == WrapMode.Loop)
                {
                    float rest = t + _delta - length;
                    ForwardTriggerEvents(_spAnim, _lastAnim, _lastIndex, t, length, false);
                    exSpriteAnimState curAnim = _spAnim.GetCurrentAnimation();
                    if (curAnim == null || _lastAnim != curAnim)
                    {
                        return(-1);
                    }
                    return(ForwardTriggerEvents(_spAnim, _lastAnim, -1, 0.0f, rest, true));
                }
                else if (_wrapMode == WrapMode.PingPong)
                {
                    float rest = t + _delta - length;
                    ForwardTriggerEvents(_spAnim, _lastAnim, _lastIndex, t, length, false);
                    exSpriteAnimState curAnim = _spAnim.GetCurrentAnimation();
                    if (curAnim == null || _lastAnim != curAnim)
                    {
                        return(-1);
                    }
                    return(BackwardTriggerEvents(_spAnim, _lastAnim, eventInfos.Count, length, length - rest, false));
                }
                else
                {
                    return(ForwardTriggerEvents(_spAnim, _lastAnim, _lastIndex, t, t + _delta, false));
                }
            }
            else
            {
                return(ForwardTriggerEvents(_spAnim, _lastAnim, _lastIndex, t, t + _delta, false));
            }
        }
        else
        {
            if (t + _delta < 0.0f)
            {
                if (_wrapMode == WrapMode.Loop)
                {
                    float rest = 0.0f - (t + _delta);
                    BackwardTriggerEvents(_spAnim, _lastAnim, _lastIndex, t, 0.0f, false);
                    exSpriteAnimState curAnim = _spAnim.GetCurrentAnimation();
                    if (curAnim == null || _lastAnim != curAnim)
                    {
                        return(-1);
                    }
                    return(BackwardTriggerEvents(_spAnim, _lastAnim, eventInfos.Count, length, length - rest, true));
                }
                else if (_wrapMode == WrapMode.PingPong)
                {
                    float rest = 0.0f - (t + _delta);
                    BackwardTriggerEvents(_spAnim, _lastAnim, _lastIndex, t, 0.0f, false);
                    exSpriteAnimState curAnim = _spAnim.GetCurrentAnimation();
                    if (curAnim == null || _lastAnim != curAnim)
                    {
                        return(-1);
                    }
                    return(ForwardTriggerEvents(_spAnim, _lastAnim, -1, 0.0f, rest, false));
                }
                else
                {
                    return(BackwardTriggerEvents(_spAnim, _lastAnim, _lastIndex, t, t + _delta, false));
                }
            }
            else
            {
                return(BackwardTriggerEvents(_spAnim, _lastAnim, _lastIndex, t, t + _delta, false));
            }
        }
    }