Beispiel #1
0
	void Start()
	{
		Debug.Log("START");
		_seq = DOTween.Sequence().SetId("SEQ");
        _seq.Append(img.DOFade(1, 0.5f));
        _seq.AppendInterval(3f);
        _seq.Append(img.DOFade(0, 0.5f));
        _seq.AppendCallback(BalloonComplete);
        // _seq.OnComplete(BalloonComplete);
	}
Beispiel #2
0
    public void FinishDay2()
    {
        canAltTab = false;
        Chat.SetActive(true);
        WorkingSpace.SetActive(false);

        GameController.isFired = false;
        Sequence seq = DOTween.Sequence();

        seq.AppendInterval(1.5f);
        seq.AppendCallback(() => Chat.TypeToYouMessage("Nice job, I'll send you your salary tomorrow, April 29th", 1f));
        seq.AppendInterval(2.5f);
        seq.AppendCallback(() => Chat.TypeFromYouMessage("But... I can swear you said that yesterday...", () => {
            seq = DOTween.Sequence();
            seq.AppendInterval(1f);
            seq.AppendCallback(() => Chat.TypeToYouMessage("Kid, have a rest. You deserved it.", 2f));
            seq.AppendInterval(4f);
            seq.AppendCallback(() => Chat.TypeFakeMessage("Where is my money Lebowski???", 3f));
            seq.AppendInterval(7f);
            seq.AppendCallback(() => Chat.TypeFromYouMessage("Ok maybe I do need a rest", () => {
                GameController.Instance.SetNight();
                seq = DOTween.Sequence();
                seq.AppendInterval(1f);
                seq.AppendCallback(() => Chat.SetActive(false));
                seq.AppendInterval(0.7f);
                seq.AppendCallback(() => {
                    SetActive(false);
                    computer.isBusy = true;
                    CanvasScript.Instance.dialog.WriteText(new Dictionary <string, float> {
                        { "Man I can swear he promised me my salary yesterday. Maybe it was a dream...", 0.05f },
                        { "Anyway, I want to sleep.", 0.05f }
                    });
                });
                seq.Play();
            }));
            seq.Play();
        }));
        seq.Play();
    }
Beispiel #3
0
        public void Destroy()
        {
            roadPartFallingSequence = DOTween.Sequence();

            if (Crystal != null)
            {
                Sequence crystallFallingSequence = DOTween.Sequence();
                crystallFallingSequence
                .PrependInterval((1.0f / ballSettings.MovingSpeed) * 3.0f * Random.value)
                .Append(Crystal.transform.DOScale(Vector3.zero,
                                                  0.5f)
                        .SetEase(Ease.InQuad))
                .AppendCallback(() => Crystal.Despawn());
                roadPartFallingSequence.Join(crystallFallingSequence);
            }

            foreach (Tile tile in Tiles)
            {
                Sequence tileFallingSequence = DOTween.Sequence();
                tileFallingSequence
                .PrependInterval((1.0f / ballSettings.MovingSpeed) * 3.0f * Random.value)
                .Append(tile.transform.DOLocalMove(
                            tile.transform.localPosition + Vector3.down,
                            0.5f)
                        .SetEase(Ease.InQuad))
                .Join(tile.transform.DOLocalRotateQuaternion(
                          tile.transform.localRotation *
                          Quaternion.Euler(Random.onUnitSphere * 10.0f),
                          0.5f)
                      .SetEase(Ease.Linear))
                .AppendCallback(() => tile.Despawn());
                roadPartFallingSequence.Join(tileFallingSequence);
            }

            roadPartFallingSequence.AppendCallback(delegate { Object.Destroy(Root.gameObject); });
        }
Beispiel #4
0
    public void SetBottleUse(bool isUse)
    {
        if (null != _animCap)
        {
            _animCap.Kill();
        }
        Sequence seq = DOTween.Sequence();

        if (true == isUse)
        {
            seq.Append(_cap.DOAnchorPos(_markCapPos + new Vector2(_cap.sizeDelta.x / 2, -(_bottle.sizeDelta.y - _cap.sizeDelta.y / 2 - 20)), _capAnimTime));
            seq.Join(_cap.DOLocalRotate(_markCapRotate + new Vector3(0, 0, -180), _capAnimTime, RotateMode.Fast));
        }
        else
        {
            seq.Append(_cap.DOAnchorPos(_markCapPos, _capAnimTime));
            seq.Join(_cap.DOLocalRotate(_markCapRotate, _capAnimTime, RotateMode.Fast));
        }
        seq.AppendCallback(() =>
        {
            _animCap = null;
        });
        _animCap = seq;
    }
Beispiel #5
0
    void GameOverSequence()
    {
        Sequence mySequence = DOTween.Sequence();

        float gridY = gridSpawner.transform.position.y;

        for (int i = 0; i < gridSpawner.BubbleGrid.Length; i++)
        {
            Bubble  bubble           = gridSpawner.BubbleGrid[i].Bubble;
            Vector3 originalPosition = bubble.transform.localPosition;

            mySequence.Insert(0f, bubble.transform
                              .DOLocalMoveY(
                                  bubble.transform.localPosition.y - gridY,
                                  0.5f)
                              .SetEase(Ease.OutBounce)
                              .OnComplete(() =>
            {
                bubble.ActivateBubble(false);
                bubble.transform.localPosition = originalPosition;
            }));

            mySequence.Insert(0f, bubble.transform
                              .DOScale(
                                  0.2f,
                                  0.5f)
                              .SetEase(Ease.OutBounce))
            .OnComplete(() =>
            {
                bubble.transform.localScale = Vector3.one;
            });
        }

        mySequence.AppendCallback(() => playLoop.GridSpawner.ClearGrid());
        mySequence.SetAutoKill(true);
    }
    void OnTriggerExit(Collider col)
    {
        if (col.tag == "Player")
        {
            m_IsPlayerIn = false;

            if (m_AISetting.type == Type.ExtremFriendly)
            {
                LockMove();
            }

            if ((m_AISetting.type == Type.Friendly) && IsOpenUmbrella)
            {
                LockMove();
                Sequence seq = DOTween.Sequence();
                seq.AppendInterval(waitDuration);
                seq.AppendCallback(delegate() {
                    if (!m_IsPlayerIn)
                    {
                        RecoverMove();
                    }
                });
            }
            if (m_AISetting.type == Type.Unfriendly && IsOpenUmbrella)
            {
                Sequence seq = DOTween.Sequence();
                seq.AppendInterval(waitDuration);
                seq.AppendCallback(delegate() {
                    if (!m_IsPlayerIn)
                    {
                        RecoverMove();
                    }
                });
            }
        }
    }
    protected override void OnBecomeInvsible(float time)
    {
        base.OnBecomeInvsible(time);

        foreach (VideoInfoUnit unit in unitList)
        {
            unit.OnBecomeInvisible(time);
        }

        Sequence seq = DOTween.Sequence();

        seq.AppendInterval(time);
        seq.AppendCallback(DisablePanel);

        foreach (VRBasicButton btn in buttonList)
        {
            btn.OnBecomeInvisible(time, false);
        }

        foreach (SidePattern p in sidePatternList)
        {
            p.OnBecomeInvisible(time);
        }
    }
    public void ShowButtons()
    {
        soundManagerRef.PlaySingle(soundManagerRef.cardsSound);
        _levelController.EnableSpawnableCellsShader();
        _levelController.ClosePopups();
        Sequence s          = DOTween.Sequence();
        int      childCount = this.transform.childCount;

        for (int i = 0; i < childCount; i++)
        {
            GameObject child = this.transform.GetChild(i).gameObject;
            s.AppendCallback(() =>
            {
                EnableButton(child);
                child.transform.DOShakePosition(0.3f, 10f);
            });
            s.AppendInterval(0.1f);
        }
        s.OnComplete(() =>
        {
            buttonsEnabled = true;
            canPressButton = true;
        });
    }
Beispiel #9
0
    public float PlayGoldAllBetToMySelf(int num)
    {
        int zhu = num / 10;

        if (zhu < 1)
        {
            zhu = 1;
        }
        float totalTime = 0;
        int   goldnum   = num / zhu;

        if (goldnum > 10)
        {
            goldnum = 10;
        }

        for (int i = 0; i < goldnum; i++)
        {
            GameObject gRes    = Resources.Load <GameObject>("Effect/gold");
            GameObject goldObj = GameObject.Instantiate <GameObject>(gRes);
            goldList.Add(goldObj);
            goldObj.transform.parent        = this.gameObject.transform.parent.transform;
            goldObj.transform.localPosition = new Vector3(0, 25, 0);
            goldObj.transform.localScale    = Vector3.zero;
            Sequence sequence = DOTween.Sequence();
            sequence.AppendInterval(i * 0.1f);
            sequence.AppendCallback(new TweenCallback(PlayGlodSound));
            sequence.Append(goldObj.GetComponent <RectTransform>().DOScale(0.6f, 0.06f));
            Tweener tweener = goldObj.GetComponent <RectTransform>().DOLocalMove(this.gameObject.transform.localPosition, 0.3f);
            sequence.Append(tweener);
            sequence.Append(goldObj.GetComponent <RectTransform>().DOScale(0, 0.06f));
            totalTime = i * 0.1f + 0.42f;
        }
        this.Invoke("PlayComplatedDestroy", totalTime);
        return(totalTime);
    }
    public static void MoveDestination(SoliderElf handle)
    {
        if (handle.Target == null)
        {
            return;
        }

        if (!handle.Target.activeSelf)
        {
            handle.Target = null;

            Sequence reback = DOTween.Sequence();
            reback.Append(handle.transform.DOLocalRotate(Vector3.zero, 0.3f));
            reback.AppendCallback(() =>
            {
                handle.State = ElfState.GoStright;
            });

            return;
        }

        Vector3 targetDirection = handle.Target.transform.position - handle.transform.position;
        float   singleStep      = handle.RotateSpeed * Time.deltaTime;
        Vector3 newDirection    = Vector3.RotateTowards(handle.transform.forward, targetDirection, singleStep, 0.0f);

        handle.transform.rotation = Quaternion.LookRotation(newDirection);

        handle.transform.Translate(handle.transform.forward * handle.MoveSpeed * Time.deltaTime);

        float dis = Vector3.Distance(handle.Target.transform.localPosition, handle.transform.localPosition);

        if (dis < (handle.AttackRange / 2f))
        {
            handle.State = ElfState.Attack;
        }
    }
    private void SwitchBtnState()
    {
        isChanging = true;

        var mainBtn = IsWeaponModel ? WeaponBtn : CallMagicBtn;
        var subBtn  = IsWeaponModel ? CallMagicBtn : WeaponBtn;

        float duration = 0.3f;

        Sequence act1 = DOTween.Sequence();

        act1.Append(mainBtn.transform.DOScale(Vector3.one, duration));
        act1.Join(mainBtn.transform.DOLocalMove(new Vector3(0, -50, 0), duration));

        act1.Join(subBtn.transform.DOScale(Vector3.one * 0.6f, duration));
        act1.Join(subBtn.transform.DOLocalMove(new Vector3(200, -125, 0), duration));

        act1.AppendCallback(() => {
            isChanging = false;

            mainBtn.transform.SetSiblingIndex(-2);
            subBtn.transform.SetSiblingIndex(-1);
        });
    }
Beispiel #12
0
    public void Contrace()
    {
        if (!_expand || _tweening)
        {
            return;
        }
        _expand   = false;
        _tweening = true;
        Sequence seq   = DOTween.Sequence();
        int      count = _content.childCount;

        for (int i = 0; i < count; ++i)
        {
            Transform c = _content.GetChild(i);
            seq.Insert(0, c.DOLocalMove(Vector3.zero, _speed).OnComplete(delegate
            {
                c.localScale = Vector3.zero;
            }));
        }
        if (_group != null)
        {
            seq.Insert(0.4f, _group.DOFade(0f, 0.1f));
        }
        seq.AppendCallback(delegate
        {
            _tweening = false;
            if (_contents.Length > 1)
            {    //可以切换显示的抽屉
                _flipIdx = ++_flipIdx % _contents.Length;
                _content = _contents[_flipIdx];
                _content.gameObject.SetActive(true);
                Expand();
            }
        });
        seq.Play();
    }
Beispiel #13
0
    public void PlayJump(string content, Vector2 location)
    {
        GetComponent <Text>().text = content;
        GetComponent <RectTransform>().anchoredPosition = location;
        GetComponent <RectTransform>().localScale       = Vector2.one;
        //GetComponent<Text>().color = Color.white;

        int   fx            = Random.Range(0, 2) == 0 ? -1 : 1;
        int   firstXOffest  = Random.Range(-20 * fx, 20 * fx);
        float secondXOffest = firstXOffest * 1.5f;

        //Tweener tweener = transform.DOMove(Vector3.zero,1f);
        //GetComponent<Text>().DOFade(0f, 1f);
        //Sequence s = GetComponent<Text>().DOFade(0f, 1f);
        Sequence s = DOTween.Sequence();

        s.Append(GetComponent <RectTransform>().DOJumpAnchorPos(location + new Vector2(firstXOffest, 0), Random.Range(40, 50), 1, Random.Range(1.1f, 1.2f)));

        s.Append(GetComponent <RectTransform>().DOJumpAnchorPos(location + new Vector2(secondXOffest, Random.Range(0, 6)), 5, 1, 0.3f));
        s.AppendCallback(SetFree);
        //s.Insert(0f, GetComponent<Text>().DOFade(0f, s.Duration()));
        s.Insert(0.2f, GetComponent <RectTransform>().DOScale(Vector2.one * 1.3f, 0.5f));
        s.Insert(0.8f, GetComponent <RectTransform>().DOScale(Vector2.one, 0.3f));
    }
Beispiel #14
0
    public static void BubbleExplosion(Transform explosion, Vector3 position, float radius, float duration, Color color)
    {
        // Main explosion
        Transform mainExplosion = explosion.lpSpawn(position, Quaternion.identity);

        mainExplosion.SetPosZ(Camera.main.transform.position.z + 1);
        MeshRenderer mainMesh = mainExplosion.GetComponent <MeshRenderer>();

        mainExplosion.localScale = new Vector3(0.1f, 0.1f, 0.1f);
        mainMesh.material.color  = color;

        Sequence ts = DOTween.Sequence();

        ts.Insert(0, mainExplosion.DOScale(radius, duration));
        ts.Insert(duration * 0.50f, mainMesh.material.DOColor(Color.white * 0.1f, duration - duration * 0.50f));

        ts.Insert(duration, mainExplosion.DOScale(radius * 1.5f, duration * 2));
        ts.Insert(duration, mainMesh.material.DOColor(Color.clear, duration * 2));

        ts.AppendCallback(() =>
        {
            mainExplosion.lpRecycle();
        });
    }
Beispiel #15
0
    // Use this for initialization
    void Start()
    {
        polygonCollider = GetComponent <PolygonCollider2D>();
        s = DOTween.Sequence();

        s.AppendCallback(() =>
        {
            polygonCollider.enabled = false;
            Time.timeScale          = 1f;

            if (GameObject.Find("PostCamera") != null)
            {
                GameObject.Find("PostCamera").SetActive(false);
            }
        })
        .Append(
            transform.DORotate(new Vector3(0, 89, 0), 0.3f)
            )
        //.AppendInterval(0.4f)
        .Append(
            transform.DORotate(Vector3.zero, 0.3f)
            )
        .OnComplete(() => { polygonCollider.enabled = true; });
    }
Beispiel #16
0
    private void PlayGoldToMyBet(int num)
    {
        int zhu = num / 10;

        if (zhu < 1)
        {
            zhu = 1;
        }
        int goldnum = num / zhu;

        if (goldnum > 10)
        {
            goldnum = 10;
        }

        PlayBorderEffect();
        float totalTime = 0;

        for (int i = 0; i < goldnum; i++)
        {
            GameObject gRes    = Resources.Load <GameObject>("Effect/gold");
            GameObject goldObj = GameObject.Instantiate <GameObject>(gRes);
            goldList.Add(goldObj);
            goldObj.transform.parent        = this.gameObject.transform;
            goldObj.transform.localPosition = Vector3.zero;
            goldObj.transform.localScale    = Vector3.zero;
            Sequence sequence = DOTween.Sequence();
            sequence.AppendInterval(i * 0.1f);
            sequence.AppendCallback(new TweenCallback(PlayGlodSound));
            sequence.Append(goldObj.GetComponent <RectTransform>().DOScale(0.6f, 0.06f));
            sequence.Append(goldObj.GetComponent <RectTransform>().DOLocalMove(new Vector3(XiaZhu.transform.localPosition.x - 23, XiaZhu.transform.localPosition.y, 0), 0.15f));
            sequence.Append(goldObj.GetComponent <RectTransform>().DOScale(0, 0.06f));
            totalTime = i * 0.1f + 0.27f;
        }
        this.Invoke("PlayComplatedDestroy", totalTime);
    }
    //show victory dialog
    public void ShowVictory()
    {
        Debug.Log("게임 3 승리");
        this.m_isCanClick = false;
        AudioManager.GetInstance().PlayEffect("sound_eff_star_2");
        DOTween.Kill(this, false);
        Sequence sequence = DOTween.Sequence();

        for (int i = 0; i < this.Model.m_map_row; i++)
        {
            for (int j = 0; j < this.Model.m_map_col; j++)
            {
                Color_Node node = this.Model.GetNode(i, j);
                float      num  = (float)(i + j) / 10f;
                sequence.Insert(num, this.m_boards[node.Index].transform.DOScale(0.95f, 0.04f));
                sequence.Insert(num + 0.2f, this.m_boards[node.Index].transform.DOScale(1.05f, 0.04f));
                sequence.Insert(num + 0.4f, this.m_boards[node.Index].transform.DOScale(1f, 0.04f));
            }
        }
        sequence.AppendCallback(delegate
        {
            CloudOnceManager.Instance.Repart_LeaderBoard(Configs.TG00301[this.Model.Map_config.ID.ToString()].Level, 3);

            GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(Resources.Load("Prefabs/G00303") as GameObject);
            gameObject.GetComponent <G3WinDialog>().Load(this.Model.Map_config.ID, this.Model.Map_config.Next, this.Model.Map_config.G003, this.Model.Map_config.Award, this.Model.Map_config.Target * 10);
            gameObject.GetComponent <G3WinDialog>().IsShowAward(GM.GetInstance().GetScoreRecord(3) + 1 <= this.Model.Map_config.ID);
            DialogManager.GetInstance().show(gameObject);

            GameObject eff_levelup = UnityEngine.Object.Instantiate <GameObject>(Resources.Load("Prefabs/effect/eff_levelup") as GameObject);
            //gameObject.transform.SetParent(base.transform, false);
            UnityEngine.Object.Destroy(eff_levelup, 5f);
            this.Model.SaveScore();
            this.Model.Mask_isVictory = true;
        });
        sequence.SetTarget(this);
    }
Beispiel #18
0
    private void TriggerAnim(Collider2D collider2d)
    {
        if (true == _isAnimating)
        {
            return;
        }
        _isAnimating = true;
        if (null != _soundTrigger)
        {
            AudioManager.PlaySound(_soundTrigger);
        }
        _state1.enabled = false;
        _state2.enabled = true;
        _model.InsertSad();
        _faceFur.TriggerFur(collider2d, true);
        Sequence sequence = DOTween.Sequence();

        sequence.AppendInterval(0.5f);
        sequence.AppendCallback(() => {
            _state1.enabled = true;
            _state2.enabled = false;
            _isAnimating    = false;
        });
    }
Beispiel #19
0
    /// <summary>
    /// 播放动画,普通出牌,飞
    /// </summary>
    /// <param name="targetPos"></param>
    public void PlaySelfOutTween(Vector3 targetPos)
    {
        Transform parent = null;

        if (GoldFiledManager.Instance.mIsGoldFiled)
        {
            parent = this.transform.parent.parent.GetChild(0).Find("outCardTargetPos");
        }
        else
        {
            parent = this.transform.parent.parent.Find("OutTargetPos");
        }

        this.transform.SetParent(parent);
        float    tweenTime  = 0.25f;
        float    endScale   = GlobalData.mPutOutCardRate;
        Sequence mySequence = DOTween.Sequence();

        //pos,scale,alpha
        mySequence.Append(this.transform.DOLocalMove(targetPos, tweenTime)).SetEase(Ease.InOutQuad);
        mySequence.Join(this.transform.DOScale(endScale, tweenTime)).SetEase(Ease.InOutQuad);
        mySequence.AppendCallback(TweenSelfCallBack);
        mySequence.Play();
    }
Beispiel #20
0
 public bool Hit(float damage)
 {
     hp = Mathf.Max(0, hp - damage);
     if (Mathf.Approximately(hp, 0))
     {
         shipState = ShipState.Dead;
         return(true);
     }
     else
     {
         if (blinkSeq == null)
         {
             blinkSeq = DOTween.Sequence();
             Color oldColour = spRenderer.color;
             blinkSeq.Append(spRenderer.DOFade(0.0f, 0.05f));
             blinkSeq.Join(spRenderer.DOBlendableColor(Color.red, 0.05f));
             blinkSeq.Append(spRenderer.DOFade(1.0f, 0.05f));
             blinkSeq.Join(spRenderer.DOBlendableColor(oldColour, 0.05f));
             blinkSeq.SetLoops(4);
             blinkSeq.AppendCallback(() => { spRenderer.color = oldColour; blinkSeq = null; });
         }
     }
     return(false);
 }
    public void AttackFinished()
    {
        if (isSurvive)
        {
            CenterCtrl.GetInstance().ECtrl.Life--;
        }

        // create a trigger collider
        Sequence action = DOTween.Sequence();

        // temporary
        ExplorePar.transform.localScale = Vector3.one * AttackRange / 2f;
        ExplorePar.Play();
        explorAudio.Play();

        action.Append(boomTrigger.transform.DOScale(Vector3.one * AttackRange, 0.2f));
        selector.ShowAttackRange();

        action.AppendCallback(() =>
        {
            boomTrigger.transform.DOScale(Vector3.zero, 0f);
            State = ElfState.Dead;
        });
    }
Beispiel #22
0
    public void StartMoveToTargetAnimation()
    {
        Sequence sequence = DOTween.Sequence();

        // 3.移动到结束点
        sequence.AppendInterval(delayOnCreatedTime);
        sequence.AppendCallback(() => {
            m_rectTransform.DOMove(targetPointRectTransform.position, tweenDuration);
            m_rectTransform.DOScale(0.4f, tweenDuration);
        });

        sequence.AppendInterval(tweenDuration);

        // 4.完成
        sequence.OnComplete(() => {
            onCompleteEvent?.Invoke();
            if (isActiveAndEnabled)
            {
                gameObject.SetActive(false);
            }
        });

        m_sequence2 = sequence;
    }
Beispiel #23
0
    public override void Interact()
    {
        text.text = "You and your friends escaped a Loop";
        Player.Instance.gameObject.SetActive(false);

        Sequence s = DOTween.Sequence();

        foreach (GameObject fren in friends)
        {
            s.AppendCallback(() => {
                Sequence s1 = DOTween.Sequence();
                s1.Append(fren.transform.DOMove(Player.Instance.transform.position, 3));
                s1.AppendCallback(() => { fren.gameObject.SetActive(false); });
            });
        }

        s.AppendInterval(5);

        s.AppendCallback(() => { GetComponent <AudioSource>().Play(); });
        s.Join(transform.GetChild(0).transform.DOShakePosition(1, 0.1f));
        s.AppendInterval(1);
        s.Join(this.transform.DOMove(transform.position + transform.up * 30, 5).SetEase(Ease.InQuint));
        s.Join(vCam.transform.DOMove(vCam.transform.position + vCam.transform.up * 20, 8).SetEase(Ease.InOutQuint));
    }
        public static Tween Push(AnimatedScreen screen)
        {
            Sequence sequence = DOTween.Sequence();

            sequence.PrependCallback(() => ValidatePushTween(sequence, screen));
            foreach (Screen otherScreen in stack)
            {
                if (otherScreen.IsEnabled)
                {
                    if (otherScreen is AnimatedScreen otherAnimatedScreen)
                    {
                        sequence.Append(otherAnimatedScreen.HideTween);
                    }
                    else
                    {
                        sequence.AppendCallback(otherScreen.Hide);
                    }
                }
            }
            sequence.Append(screen.ShowTween
                            .AddOnComplete(() => stack.Push(screen)));

            return(sequence);
        }
Beispiel #25
0
        public void Update()
        {
            if (!Renderer.isVisible && !correctingSpeed)
            {
                tween.Kill();
                tween           = DOTween.Sequence();
                correctingSpeed = true;
                if ((transform.position - RunController.transform.position).x < 0)
                {
                    tween.Append(DOTween.To(() => Speed, (spd) => Speed = spd, RunController.MaxSpeed, UnityEngine.Random.Range(RunController.MinSpeedTweenTime, RunController.MaxSpeedTweenTime)));
                }
                else
                {
                    tween.Append(DOTween.To(() => Speed, (spd) => Speed = spd, RunController.MinSpeed, UnityEngine.Random.Range(RunController.MinSpeedTweenTime, RunController.MaxSpeedTweenTime)));
                }

                tween.AppendInterval(UnityEngine.Random.Range(RunController.MinSpeedTweenDelay, RunController.MaxSpeedTweenDelay));
                tween.AppendCallback(() => correctingSpeed = false);
                tween.OnComplete(ChangeSpeed);
            }

            Collider.transform.rotation = Quaternion.Euler(0, 0, (float)(Speed * Time.deltaTime * RunController.RotationSpeedMultiplier / Radius));
            transform.position         += speed * Time.deltaTime * Vector3.right;
        }
    public void ActivateNotificationSequence()
    {
        isAnimating = true;

        Sequence notifSequence = DOTween.Sequence();

        notifSequence.AppendCallback(() => { ActivateNotificationBackground(titleBox, originalTitleBoxHeight); });
        notifSequence.AppendInterval(notificationAnimateTime + 0.1f);
        notifSequence.AppendCallback(() => ActivateText(titleText));

        notifSequence.AppendInterval(notificationAnimationNextPhaseTime);

        notifSequence.AppendCallback(() => { ActivateNotificationBackground(descriptionBox, originalDescriptionBoxHeight); });
        notifSequence.AppendInterval(notificationAnimateTime + 0.1f);
        notifSequence.AppendCallback(() => ActivateText(descriptionText));
        notifSequence.AppendCallback(() => { isAnimating = false; });

        notifSequence.AppendInterval(notificationDeactivateDelay);
        notifSequence.AppendCallback(() => { DeactivateNotificationSequence(); });
    }
 private void runGameOverSequence()
 {
     _crossHair.SetActive(false);
     _fader.enabled = true;
     _fader.color   = new Color(0, 0, 0, 0);
     _sequence      = DOTween.Sequence();
     _sequence.AppendCallback(() => { _outroCamera.gameObject.SetActive(true); });
     _sequence.AppendInterval(2);
     _sequence.AppendCallback(() => { ShowSubtitles.Instance.ShowOutroSubtitles(); });
     _sequence.AppendInterval(10);
     _sequence.AppendCallback(() =>
     {
         _fire.transform.DOScaleY(0, 1);
         _fire.transform.DOMoveY(0.5f, 1);
     });
     _sequence.AppendInterval(1);
     _sequence.AppendCallback(() => { _fire.SetActive(false); });
     _sequence.AppendInterval(5);
     _sequence.AppendCallback(() => _fire.SetActive(false));
     _sequence.Append(_fader.DOColor(Color.black, 0));
     _sequence.AppendInterval(3);
     _sequence.AppendCallback(() => _gamedata.LoadGameOverScene());
 }
Beispiel #28
0
    public void Walk()
    {
        if (_State == State.WALK || _State == State.DIE)
        {
            return;
        }
        _State = State.WALK;
        Sequence sequence = DOTween.Sequence();

        sequence.AppendCallback(ChangeFrame1);
        sequence.AppendInterval(delay);
        sequence.AppendCallback(ChangeFrame2);
        sequence.AppendInterval(delay);
        sequence.AppendCallback(ChangeFrame3);
        sequence.AppendInterval(delay);
        sequence.AppendCallback(ChangeFrame4);
        sequence.AppendInterval(delay);
        sequence.AppendCallback(ChangeFrame5);
        sequence.AppendInterval(delay);
        sequence.AppendCallback(ChangeFrame6);
        sequence.AppendInterval(delay);
        sequence.SetLoops(-1);
        sequence.SetTarget(this);
    }
 public override void Out(Sequence sequence)
 {
     sequence.AppendCallback(() => _target.localScale = _originalScale);
     sequence.Append(_target.DOScale(Vector3.zero, _duration));
     sequence.SetEase(_ease);
 }
Beispiel #30
0
        private void SubscribeState(StateType stateType)
        {
            Find <ItemInformationTooltip>().Close();
            inventory.SharedModel.DeselectItemView();
            shopItems.SharedModel.DeselectItemView();
            buyButton.SetInteractable(false, true);
            sellButton.SetInteractable(false, true);
            buyImage.gameObject.SetActive(false);
            sellImage.gameObject.SetActive(false);
            switch (stateType)
            {
            case StateType.Show:
                shopItems.SharedModel.State.Value = stateType;
                shopNotice.SetActive(false);
                _toggleGroup.SetToggledOn(buyButton);
                _isStateShowBefore = true;
                return;

            case StateType.Buy:
                inventory.SharedModel.DimmedFunc.Value = null;
                shopNotice.SetActive(false);
                _toggleGroup.SetToggledOn(buyButton);

                if (_isStateShowBefore)
                {
                    _isStateShowBefore = false;
                    shopItems.SharedModel.State.Value = stateType;
                    buyButton.SetInteractable(false, true);
                    sellButton.SetInteractable(true, true);
                    buyImage.gameObject.SetActive(true);
                    return;
                }
                break;

            case StateType.Sell:
                inventory.SharedModel.DimmedFunc.Value = DimmedFuncForSell;
                shopNotice.SetActive(true);
                _toggleGroup.SetToggledOn(sellButton);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(stateType), stateType, null);
            }

            canvasGroup.interactable = false;
            rightCanvasGroup.alpha   = 0;
            if (_sequenceOfShopItems is null)
            {
                Animator.enabled     = false;
                _sequenceOfShopItems = DOTween.Sequence();
                SetSequenceOfShopItems(true, ref _sequenceOfShopItems);
                _sequenceOfShopItems.AppendCallback(() =>
                                                    shopItems.SharedModel.State.Value = stateType);
                SetSequenceOfShopItems(false, ref _sequenceOfShopItems);
                _sequenceOfShopItems.OnComplete(() =>
                {
                    rightCanvasGroup.DOFade(1f, 0.5f).OnComplete(() =>
                    {
                        Animator.enabled         = true;
                        canvasGroup.interactable = true;
                        _sequenceOfShopItems     = null;
                        buyButton.SetInteractable(stateType == StateType.Sell, true);
                        sellButton.SetInteractable(stateType == StateType.Buy, true);
                        var isSell = stateType == StateType.Sell;
                        buyImage.gameObject.SetActive(!isSell);
                        sellImage.gameObject.SetActive(isSell);
                    });
                });
            }
        }
Beispiel #31
0
    public float PlayGoldToAllBet(int num)
    {
        if (!string.IsNullOrEmpty(XiaZhuNum.text))
        {
            num = int.Parse(XiaZhuNum.text);
        }
        int zhu = num / 10;

        if (zhu < 1)
        {
            zhu = 1;
        }
        int goldnum = num / zhu;

        if (goldnum > 10)
        {
            goldnum = 10;
        }

        float totalTime = 0;

        for (int i = 0; i < goldnum; i++)
        {
            GameObject gRes    = Resources.Load <GameObject>("Effect/gold");
            GameObject goldObj = GameObject.Instantiate <GameObject>(gRes);
            goldList.Add(goldObj);
            goldObj.transform.parent        = this.gameObject.transform.parent.transform;
            goldObj.transform.localPosition = this.gameObject.transform.localPosition;
            goldObj.transform.localScale    = Vector3.zero;
            Sequence sequence = DOTween.Sequence();
            sequence.AppendInterval(i * 0.1f);
            sequence.AppendCallback(new TweenCallback(PlayGlodSound));
            sequence.Append(goldObj.GetComponent <RectTransform>().DOScale(0.6f, 0.06f));

            //Vector3 startP = this.gameObject.transform.localPosition;
            //Vector3 endP = new Vector3(10, 20, 0);
            //Vector3 centerP = (startP + endP) * 0.5f;
            //Vector3 centorProject = Vector3.Project(centerP, startP - endP); // 中心点在两点之间的投影
            //centerP = Vector3.MoveTowards(centerP, centorProject, 4f); // 沿着投影方向移动移动距离(距离越大弧度越小) 
            ////我们把中心点向下移动中心,垂直于弧线  
            //centerP += new Vector3(0, 4f, 0);
            //// 求出新的中心点到向量a和向量b的  
            //Vector3 vecA = startP - centerP;
            //Vector3 vecB = endP - centerP;

            //Vector3[] pathPoss = new Vector3[5];
            //pathPoss[0] = this.gameObject.transform.localPosition;
            //pathPoss[1] = Vector3.Slerp(vecA, vecB, 0.25f) + centerP;
            //pathPoss[2] = Vector3.Slerp(vecA, vecB, 0.5f) + centerP;
            //pathPoss[3] = Vector3.Slerp(vecA, vecB, 0.75f) + centerP;
            //pathPoss[4] = new Vector3(10, 20, 0);

            //Tweener tweener = goldObj.GetComponent<RectTransform>().DOLocalPath(pathPoss, 0.3f, PathType.CatmullRom);
            Tweener tweener = goldObj.GetComponent <RectTransform>().DOLocalMove(new Vector3(0, 25, 0), 0.3f);
            sequence.Append(tweener);
            sequence.Append(goldObj.GetComponent <RectTransform>().DOScale(0, 0.06f));
            totalTime = i * 0.1f + 0.42f;
        }
        this.Invoke("PlayComplatedDestroy", totalTime);
        return(totalTime);
    }