예제 #1
0
    public void OnFlickCancelAnimationRequired(FlickableCorner flickableCorner, Vector2 initialPosition, Action onDone)
    {
        var rectTrans = flickableCorner.GetComponent <RectTransform>();

        IEnumerator cancel()
        {
            var count = 0;

            while (true)
            {
                rectTrans.anchoredPosition = rectTrans.anchoredPosition + (initialPosition - rectTrans.anchoredPosition) * 0.5f;
                flickableCorner.UpdateRelatedCornerPositions();

                if (count == 10)
                {
                    onDone();
                    yield break;
                }
                count++;
                yield return(null);
            }
        }

        StartCoroutine(cancel());
    }
예제 #2
0
    public void FlickableCornerWillAppear(FlickableCorner flickableCorner)
    {
        // Debug.Log("FlickableCornerWillAppear:" + flickableCorner);
        switch (flickableCorner.name)
        {
        case "FrickableCorner1":
            selectIndicator(0);
            break;

        case "FrickableCorner2":
            selectIndicator(1);
            break;

        case "FrickableCorner3":
            selectIndicator(2);
            break;

        case "FrickableCorner4":
            selectIndicator(3);
            break;

        default:
            Debug.Log("unhandled corner:" + flickableCorner.name);
            break;
        }
    }
    public void OnFlickProcessAnimationRequired(FlickableCorner flickableCorner, Vector2 targetPosition, Action onDone, Action onCancelled)
    {
        var rectTrans = flickableCorner.GetComponent <RectTransform>();

        animating = true;
        var waitGroup = new WaitGroup(
            () => animating = false
            );

        waitGroup.AddWait(rectTrans);
        IEnumerator process()
        {
            var count = 0;

            while (true)
            {
                rectTrans.anchoredPosition = rectTrans.anchoredPosition + (targetPosition - rectTrans.anchoredPosition) * 0.5f;
                flickableCorner.UpdateRelatedCornerPositions();

                if (count == 10)
                {
                    onDone();
                    waitGroup.RemoveWait(rectTrans);
                    yield break;
                }
                count++;
                yield return(null);
            }
        }

        StartCoroutine(process());
    }
예제 #4
0
 public void FlickableCornerAppearCancelled(FlickableCorner flickableCorner)
 {
     // Debug.Log("AppearCancelled:" + flickableCorner);
     if (flickableCorner.gameObject.name.Contains("FrickableCornerPrefab"))
     {
         // prefabから作ったやつだったら消す
         Destroy(flickableCorner.gameObject);
     }
 }
예제 #5
0
 public void FlickableCornerDidDisappear(FlickableCorner flickableCorner)
 {
     // Debug.Log("DidDisappear:" + flickableCorner);
     if (flickableCorner.gameObject.name.Contains("FrickableCornerPrefab"))
     {
         // prefabから作ったやつだったら消す
         Destroy(flickableCorner.gameObject);
     }
 }
        internal void Join(FlickableCorner flickableCorner)
        {
            if (network.Contains(flickableCorner))
            {
                return;
            }

            network.Add(flickableCorner);
        }
예제 #7
0
    // フリックの開始時にリクエストを検知し、ビューの建て増しと削除が可能になる。
    public bool OnFlickRequestFromFlickableCorner(FlickableCorner flickingCorner, ref Corner cornerFromLeft, ref Corner cornerFromRight, ref Corner cornerFromTop, ref Corner cornerFromBottom, FlickDirection plannedFlickDir)
    {
        Debug.Log("OnFlickRequestFromFlickableCorner:" + Time.frameCount);
        // leftが空なFlickableCornerに対して右フリックをした際、左側にコンテンツを偽造する
        if (plannedFlickDir == FlickDirection.RIGHT && cornerFromLeft == null)
        {
            // cornerFromLeftに代入する
            var newCorner = Instantiate(FlickableCornerPrefab, this.transform).GetComponent <FlickableCorner>();

            // 作成したcornerを、現在flick操作中のcornerの左側にくるようにセット
            newCorner.currentRectTransform().anchoredPosition = new Vector2(flickingCorner.currentRectTransform().anchoredPosition.x - flickingCorner.currentRectTransform().sizeDelta.x, flickingCorner.currentRectTransform().anchoredPosition.y);
            newCorner.CornerFromRight = flickingCorner;
            cornerFromLeft            = newCorner;
            count++;

            // ボタンにカウント表示をセットする
            if (newCorner.TryExposureContents <Button>(out var buttons))
            {
                var text = buttons[0].GetComponentInChildren <Text>();
                text.text = text.text + ":" + count;
            }
            else
            {
                Debug.LogError("ボタンがない 1");
            }
            return(true);
        }

        // rightが空なFlickableCornerに対して左フリックをした際、右側にコンテンツを偽造する
        if (plannedFlickDir == FlickDirection.LEFT && cornerFromRight == null)
        {
            // cornerFromRightに代入する
            var newCorner = Instantiate(FlickableCornerPrefab, this.transform).GetComponent <FlickableCorner>();

            // 作成したcornerを、現在flick操作中のcornerの右側にくるようにセット
            newCorner.currentRectTransform().anchoredPosition = new Vector2(flickingCorner.currentRectTransform().anchoredPosition.x + flickingCorner.currentRectTransform().sizeDelta.x, flickingCorner.currentRectTransform().anchoredPosition.y);
            newCorner.CornerFromLeft = flickingCorner;
            cornerFromRight          = newCorner;
            count++;

            // ボタンにカウント表示をセットする
            if (newCorner.TryExposureContents <Button>(out var buttons))
            {
                var text = buttons[0].GetComponentInChildren <Text>();
                text.text = text.text + ":" + count;
            }
            else
            {
                Debug.LogError("ボタンがない 2");
            }
            return(true);
        }

        return(true);
    }
    public void OnDragReachedOnGrid(int index, GameObject go)
    {
        // 表示を更新する
        OnDragApproachingToGrid(index, go);

        var fromIndex = SegOneOfNButtonsCorner.GetIndexOfOne();

        // 変化がないので終了
        if (index == fromIndex)
        {
            return;
        }

        // dragが終わったgridのindexを元に、sequeを選択した状態にする。
        SelectSegue(index);

        // flickableを移動する
        if (FlickableCornersCorner.TryExposureCorners <FlickableCorner>(out var flickableCorners))
        {
            // from to の導出
            var fromFlickableCorner   = flickableCorners[fromIndex];
            var targetFlickableCorner = flickableCorners[index];

            // sequeが操作されたので、flickableCornerの中でフォーカスしてあるものを変更する。
            if (FlickableCorner.TryFindingAutoFlickRoute(fromFlickableCorner, targetFlickableCorner, out var flickDriver))
            {
                // TODO: このへんでdriverを持っておくとおもしろそう。stopしたいので、、

                animating = true;

                var wait = new WaitGroup(
                    () => animating = false
                    );

                wait.AddWait(flickDriver);
                IEnumerator driveCor()
                {
                    while (flickDriver.MoveNext())
                    {
                        yield return(null);
                    }
                    wait.RemoveWait(flickDriver);
                };

                // 開始する
                StartCoroutine(driveCor());
            }
        }
    }
예제 #9
0
 public void FlickableCornerDisppearCancelled(FlickableCorner flickableCorner)
 {
     // Debug.Log("DisppearCancelled:" + flickableCorner);
 }
    }                                                                                                 // 何もしない

    public void OnOneOfNChangedToOneByPlayer(GameObject one, GameObject before, GameObject[] all)
    {
        // プレイヤーがUI上のButton1~4のどれかを押したので、flickViewとfloatButtonを移動させる。
        if (FlickableCornersCorner.TryExposureCorners <FlickableCorner>(out var flickableCorners))
        {
            // fromの検出
            var fromIndex = -1;
            switch (before.name)
            {
            case "Button1":
                fromIndex = 0;
                break;

            case "Button2":
                fromIndex = 1;
                break;

            case "Button3":
                fromIndex = 2;
                break;

            case "Button4":
                fromIndex = 3;
                break;

            default:
                Debug.LogError("unhandled:" + one.name);
                return;
            }

            // toの検出
            var toIndex = -1;
            switch (one.name)
            {
            case "Button1":
                toIndex = 0;
                break;

            case "Button2":
                toIndex = 1;
                break;

            case "Button3":
                toIndex = 2;
                break;

            case "Button4":
                toIndex = 3;
                break;

            default:
                Debug.LogError("unhandled:" + one.name);
                return;
            }

            // from to の導出
            var fromFlickableCorner   = flickableCorners[fromIndex];
            var targetFlickableCorner = flickableCorners[toIndex];

            // sequeが操作されたので、flickableCornerの中でフォーカスしてあるものを変更する。
            if (FlickableCorner.TryFindingAutoFlickRoute(fromFlickableCorner, targetFlickableCorner, out var flickDriver))
            {
                // TODO: このへんでdriverを持っておくとおもしろそう。stopしたいので、、

                // draggableをtoIndexに向けて動かす
                var dragDriver = draggableDriver(fromIndex, toIndex);

                animating = true;

                var wait = new WaitGroup(
                    () => animating = false
                    );

                wait.AddWait(flickDriver);
                wait.AddWait(dragDriver);

                IEnumerator flickDriveCor()
                {
                    while (flickDriver.MoveNext())
                    {
                        yield return(null);
                    }
                    wait.RemoveWait(flickDriver);
                };
                IEnumerator dragDriveCor()
                {
                    while (dragDriver.MoveNext())
                    {
                        yield return(null);
                    }
                    wait.RemoveWait(dragDriver);
                };

                // 開始する
                StartCoroutine(flickDriveCor());
                StartCoroutine(dragDriveCor());
            }
        }
    }
예제 #11
0
 public void FlickableCornerWillDisappear(FlickableCorner flickableCorner)
 {
     // Debug.Log("WillDisappear:" + flickableCorner);
 }
    // flicableCorner関連

    public bool OnFlickRequestFromFlickableCorner(FlickableCorner flickableCorner, ref Corner cornerFromLeft, ref Corner cornerFromRight, ref Corner cornerFromTop, ref Corner cornerFromBottom, FlickDirection plannedFlickDir)
    {
        return(true);
    }
예제 #13
0
 public void FlickableCornerDidAppear(FlickableCorner flickableCorner)
 {
     // Debug.Log("FlickableCornerDidAppear:" + flickableCorner);
 }
 public void FlickableCornerWillBack(FlickableCorner flickableCorner)
 {
 }
 public void FlickableCornerDisppearProgress(FlickableCorner flickableCorner, float progress)
 {
 }
 public void FlickableCornerWillCancel(FlickableCorner flickableCorner)
 {
 }
예제 #17
0
    /*
     *  flickableCornerに対して、flick操作に応じて関連するcornerの出現や消滅、progressを取得することができる。
     *  また、対象方向へのflick先が存在しない場合、OnFlickRequestFromFlickableCornerが呼び出され、その中でcornerを追加したり接続を切り替えることで
     *  無限にflick先を生成する、などができる。
     */

    public void FlickableCornerWillBack(FlickableCorner flickableCorner)
    {
        // Debug.Log("FlickableCornerWillBack:" + flickableCorner);
    }
    public void FlickableCornerWillAppear(FlickableCorner flickableCorner)
    {
        // Debug.Log("FlickableCornerWillAppear animating:" + animating);
        var targetIndex = -1;

        switch (flickableCorner.name)
        {
        case "FlickableCorner1":
            targetIndex = 0;
            break;

        case "FlickableCorner2":
            targetIndex = 1;
            break;

        case "FlickableCorner3":
            targetIndex = 2;
            break;

        case "FlickableCorner4":
            targetIndex = 3;
            break;

        default:
            Debug.LogError("unhandled corner:" + flickableCorner);
            break;
        }

        // 該当なし
        if (targetIndex == -1)
        {
            return;
        }

        var currentIndexOfSegue = SegOneOfNButtonsCorner.GetIndexOfOne();

        // 現在既に選択されているindexだった場合、何も起こらない
        if (currentIndexOfSegue == targetIndex)
        {
            return;
        }

        // floatButtonを移動させる
        {
            var dragDriver = draggableDriver(currentIndexOfSegue, targetIndex);

            animating = true;

            var wait = new WaitGroup(
                () => animating = false
                );

            wait.AddWait(dragDriver);
            IEnumerator driveCor()
            {
                while (dragDriver.MoveNext())
                {
                    yield return(null);
                }

                wait.RemoveWait(dragDriver);
            };

            // 開始する
            StartCoroutine(driveCor());
        }

        // 特定のindexのsequeを選択状態にする。
        SelectSegue(targetIndex);
    }
 public void FlickableCornerDidDisappear(FlickableCorner flickableCorner)
 {
 }
 public void FlickableCornerDisppearCancelled(FlickableCorner flickableCorner)
 {
 }
예제 #21
0
 public void FlickableCornerDisppearProgress(FlickableCorner flickableCorner, float progress)
 {
     // Debug.Log("DisppearProgress:" + flickableCorner + " progress:" + progress);
 }
예제 #22
0
 public void FlickableCornerWillCancel(FlickableCorner flickableCorner)
 {
     // Debug.Log("FlickableCornerWillCancel:" + flickableCorner);
 }
    public void OnOneOfNChangedToOneByPlayer(GameObject one, GameObject before, GameObject[] all)
    {
        // sequeのどれか一つがUI操作によって更新された

        // UIの調整
        foreach (var a in all)
        {
            var button = a.GetComponent <Button>();

            // aがoneと一緒だった場合、選択されているのでinteractableをfalseにする。
            if (a == one)
            {
                button.interactable = false;
                continue;
            }

            // 選択されていないのでinteractableをtrueにする。
            button.interactable = true;
        }

        // flickDetectorからCornerを取得し、そこに含まれているFlickableCorner群を取り出し、どれか目指して進む。
        var corner = flickDetector.GetComponent <Corner>();

        if (corner.TryExposureCorners <FlickableCorner>(out var flickableCorners))
        {
            // fromの検出
            FlickableCorner fromFlickableCorner = null;
            switch (before.name)
            {
            case "Button1":
                fromFlickableCorner = flickableCorners[0];
                break;

            case "Button2":
                fromFlickableCorner = flickableCorners[1];
                break;

            case "Button3":
                fromFlickableCorner = flickableCorners[2];
                break;

            case "Button4":
                fromFlickableCorner = flickableCorners[3];
                break;

            default:
                Debug.LogError("unhandled:" + one.name);
                return;
            }

            // toの検出
            FlickableCorner targetFlickableCorner = null;
            switch (one.name)
            {
            case "Button1":
                targetFlickableCorner = flickableCorners[0];
                break;

            case "Button2":
                targetFlickableCorner = flickableCorners[1];
                break;

            case "Button3":
                targetFlickableCorner = flickableCorners[2];
                break;

            case "Button4":
                targetFlickableCorner = flickableCorners[3];
                break;

            default:
                Debug.LogError("unhandled:" + one.name);
                return;
            }

            // sequeが操作されたので、flickableCornerの中でフォーカスしてあるものを変更する。
            if (FlickableCorner.TryFindingAutoFlickRoute(fromFlickableCorner, targetFlickableCorner, out var driver))
            {
                // TODO: このへんでdriverを持っておくとおもしろそう。stopしたいので、、
                IEnumerator driveCor()
                {
                    while (driver.MoveNext())
                    {
                        yield return(null);
                    }
                };

                // 開始する
                StartCoroutine(driveCor());
            }
        }
    }
 public void FlickableCornerWillDisappear(FlickableCorner flickableCorner)
 {
 }