示例#1
0
        public override void OnInspectorGUI()
        {
            UTween o = this.target as UTween;

            EGUIUtility.EnumPop(ProMode, "Mode");
            DrawCounter(o);
            DrawGroupNumber(o);
            OnDrawChildren();
            EditorGUILayout.DelayedFloatField(ProDuration, NAME_DURATION);
            EditorGUILayout.DelayedFloatField(ProDelayTime, NAME_DELAYTIME);
            if (ProDuration.floatValue <= 0)
            {
                ProDuration.floatValue = 1f;
            }
            if (ProDelayTime.floatValue < 0)
            {
                ProDelayTime.floatValue = 0;
            }
            //Rect rect = new Rect(Vector2.zero, Vector2.one);
            //rect.xMin = -100;
            //rect.xMax = 100;
            //rect.yMin = -100;
            //rect.yMax = 100;
            //rect.center = new Vector2(0.5f,0.5f);
            //rect.x = 0;
            //rect.y = 0;
            //EditorGUILayout.CurveField(ProCurve, Color.green, rect, NAME_CURVE, GUILayout.Height(80));
            ProCurve.animationCurveValue = EditorGUILayout.CurveField(ProCurve.animationCurveValue, GUILayout.Height(80));
            DrawToggle();

            serializedObject.ApplyModifiedProperties();
        }
示例#2
0
    public override IEnumerator DamageAnim(int delta)
    {
        float fromHp = Hp;
        float toHp   = Utils.Clamp(Hp - delta, 0, MaxHp);

        var fromAmount = fromHp / MaxHp;
        var toAmount   = toHp / MaxHp;

        Debug.LogFormat("amount fm:{0} to:{1}", fromAmount, toAmount);

        var imageFg = GameObject.Find("Canvas/Header/Image_HP_FG").GetComponent <Image>();
        var imageMg = GameObject.Find("Canvas/Header/Image_HP_MG").GetComponent <Image>();

        var textHp = GameObject.Find("Canvas/Header/Text_HP_Value").GetComponent <Text>();

        textHp.text = string.Format("{0}/{1}", toHp, MaxHp);

        imageFg.fillAmount = toAmount;
        imageMg.fillAmount = fromAmount;
        yield return(new WaitForSeconds(0.53f));

        float duration = 0.3f;
        float elapsed  = 0;

        while (elapsed <= duration)
        {
            elapsed += Time.deltaTime;
            float p = UTween.Ease(EaseType.OutQuad, fromAmount, toAmount, elapsed / duration);
            imageMg.fillAmount = p;
            yield return(null);
        }
        imageMg.fillAmount = toAmount;
    }
示例#3
0
    private IEnumerator Test()
    {
        int fm = 0;
        int to = 35;

        List <GameObject> digits = null;

        float duration = 0.33f;
        float elapsed  = 0;

        // カウントアップ
        while (elapsed <= duration)
        {
            elapsed += Time.deltaTime;
            int x = (int)UTween.Ease(EaseType.OutQuad, fm, to, elapsed / duration);
            if (digits != null)
            {
                foreach (var d in digits)
                {
                    Destroy(d);
                }
            }
            digits = D(x);
            yield return(null);
        }
        yield return(new WaitForSeconds(0.4f));

        elapsed  = 0;
        duration = 0.32f;

        var src = _player.Position;
        var dst = _player.Position + new Vector3(0, 0.23f, 0);

        while (elapsed <= duration)
        {
            elapsed += Time.deltaTime;
            float y = Mathf.Lerp(src.y, dst.y, elapsed / duration);
            foreach (var d in digits)
            {
                var p = d.transform.position;
                d.transform.position = new Vector3(p.x, y, p.z);

                var renderer = d.GetComponent <SpriteRenderer>();
                var color    = renderer.color;
                var a        = UTween.Ease(EaseType.InQuint, 1.0f, 0, elapsed / duration);
                color.a        = a;
                renderer.color = color;
            }
            yield return(null);
        }

        foreach (var d in digits)
        {
            Destroy(d);
        }
    }
示例#4
0
文件: Enemy.cs 项目: m-ishikawa/Rlike
    public override IEnumerator DamageAnim(int delta) {
        int fm = Hp;
        int to = Utils.Clamp(Hp - delta, 0, MaxHp);

        float greenScale = to * HP_GAUGE_MAX_SCALE / MaxHp;
        _barGreen.transform.localScale = new Vector3(greenScale, 1, 1);
        yield return new WaitForSeconds(0.43f);

        float duration = 0.3f;
        yield return CAction.Run(duration, elapsed => {
           float p = UTween.Ease(EaseType.OutQuad, fm, to, elapsed / duration);
            float scale = p * HP_GAUGE_MAX_SCALE / MaxHp;
            _barYellow.transform.localScale = new Vector3(scale, 1, 1);
        });
    }
示例#5
0
        void DrawCounter(UTween o)
        {
            if (this.targets.Length > 1)
            {
                EditorGUILayout.DelayedIntField(ProCounter, NAME_COUNTER);
                return;
            }

            EditorGUILayout.BeginVertical();
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("Counter");
            int idx = 0;

            if (ProCounter.intValue == 0)
            {
                idx = 1;
            }
            else if (ProCounter.intValue > 0)
            {
                idx = 2;
            }
            else
            {
                idx = 0;
            }
            idx = GUILayout.Toolbar(idx, CounterBar);
            if (idx == 0)
            {
                ProCounter.intValue = -1;
            }
            else if (idx == 1)
            {
                ProCounter.intValue = 0;
            }
            else if (ProCounter.intValue < 1)
            {
                ProCounter.intValue = 1;
            }
            EditorGUILayout.EndHorizontal();
            if (idx == 2)
            {
                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PrefixLabel("Value");
                ProCounter.intValue = EditorGUILayout.DelayedIntField(ProCounter.intValue);
                EditorGUILayout.EndHorizontal();
            }
            EditorGUILayout.EndVertical();
        }
示例#6
0
    public IEnumerator CameraZoom(float delta)
    {
        var   camera = GameObject.Find("Main Camera").GetComponent <Camera>();
        float src    = OrthographicSize;
        float dst    = src + delta;

        float duration = 0.5f;
        float elapsed  = 0;

        while (elapsed <= duration)
        {
            elapsed += Time.deltaTime;
            float size = UTween.Ease(EaseType.OutCubic, src, dst, elapsed / duration);
            camera.orthographicSize = size;
            yield return(null);
        }
        camera.orthographicSize = dst;
    }
示例#7
0
        void DrawGroupNumber(UTween o)
        {
            if (this.targets.Length > 1)
            {
                EditorGUILayout.DelayedIntField(ProGroup, NAME_GROUP);
                return;
            }

            EditorGUILayout.BeginVertical();
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("Group");
            int idx = 0;

            if (ProGroup.intValue == 0)
            {
                idx = 0;
            }
            else
            {
                idx = 1;
            }
            idx = GUILayout.Toolbar(idx, GroupBar);
            if (idx == 0)
            {
                ProGroup.intValue = 0;
            }
            else if (ProGroup.intValue == 0)
            {
                ProGroup.intValue = 1;
            }
            EditorGUILayout.EndHorizontal();
            if (idx == 1)
            {
                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PrefixLabel("Value");
                ProGroup.intValue = EditorGUILayout.DelayedIntField(ProGroup.intValue);
                EditorGUILayout.EndHorizontal();
            }
            EditorGUILayout.EndVertical();
        }
示例#8
0
    public override IEnumerator Use(CharacterBase sender, MainSystem sys)
    {
        var   src      = sender.Position;
        float duration = 0.5f;
        float elapsed  = 0;

        while (elapsed <= duration)
        {
            float y = UTween.Ease(EaseType.InCubic, src.y, src.y + 6, elapsed / duration);
            sender.Position = new Vector3(src.x, y, 0);
            elapsed        += Time.deltaTime;
            yield return(null);
        }
        yield return(new WaitForSeconds(0.36f));

        var loc = sys.Warp(sender.Loc, true);

        sender.Position = loc.ToPosition();
        sender.ChangeDir(Dir.S);
        sender.UpdateLoc(loc);
        yield return(new WaitForSeconds(0.4f));
    }
示例#9
0
        private void Start()
        {
            // Common Style

            /*
             * var tween = UTween.Create<TweenValue>();
             * tween.SetFrom(0f);
             * tween.SetTo(1f);
             * tween.SetDuration(2f);
             * tween.SetFloatCallback(value =>
             * {
             * Debug.Log("Value : " + value);
             * });
             * tween.Play();
             */

            // Chain Style
            UTween.Create <TweenValue>()
            .SetFrom(0f)
            .SetTo(1f)
            .SetDuration(2f)
            .SetUpdateType(UpdateType.Update)
            .SetPlayType(PlayType.PingPong)
            .SetEaseType(EaseType.Linear)
            .SetTimeScale(false)
            .SetPlayCallback(() => { Debug.Log("Play"); })
            .SetFloatCallback(value =>
            {
                var color      = AlphaObj.color;
                AlphaObj.color = new Color(color.r, color.g, color.b, value);
            })
            .SetStopCallback(() => { Debug.Log("Stop"); })
            .Play();

            TweenAlpha.Play();

            UTween.Value(0f, 1f, 1f, value =>
            {
                Debug.Log(value);
            }).SetStartDelay(3f);

            UTween.Shake(ShakePos, 0.5f, 0f, 0f, 5, 0.5f).SetPlayType(PlayType.Loop);
            UTween.Shake(ShakeRot, 0f, 45f, 0f, 5, 0.5f).SetPlayType(PlayType.Loop);
            UTween.Shake(ShakeScale, 0f, 0f, 0.5f, 5, 0.5f).SetPlayType(PlayType.Loop);

            UTween.GetSequence()
            .Append(UTween.Position(SequenceMoveObj, Vector3.zero, Vector3.one, 2f))
            .Append(UTween.Position(SequenceMoveObj, Vector3.one, Vector3.up, 2f))
            .Append(UTween.Position(SequenceMoveObj, Vector3.up, Vector3.left, 2f))
            .Append(UTween.Position(SequenceMoveObj, Vector3.left, Vector3.zero, 2f))
            .SetStartDelay(3f)
            .Play();

            UTween.GetParallel()
            .Append(UTween.Position(ParallelMoveObj1, new Vector3(2, 0, 0), new Vector3(4, 0, 0), 2f))
            .Append(UTween.Position(ParallelMoveObj2, new Vector3(2, 2, 0), new Vector3(4, 2, 0), 2f))
            .SetStartDelay(3f)
            .Play();

            // Tween Group

            /*
             * var tweeners = gameObject.GetTweeners("Open");
             * tweeners.Play();
             */

            // Dynamic from / to value

            /*
             * float FromValue = 0f;
             * float ToValue = 0f;
             * UTween.Value(0f, 5f, 1f, value => FromValue = value);
             * UTween.Value(10f, 5f, 1f, value => ToValue = value);
             * UTween.Create<TweenValue>()
             * .SetFromGetter(()=> FromValue)
             * .SetToGetter(()=> ToValue)
             * .SetDuration(1f)
             * .SetUpdateType(UpdateType.LateUpdate)
             * .Play();
             */

            UTween.Create(Asset)
            .SetTarget(TweenPosTarget)
            .Play();
        }