garden_client/Assets/Script/Object/Garden.cs

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;

using System.Collections;
using System.Collections.Generic;

public enum Direction
{
    Left,
    Null,
    Right,
}

public class Garden : Regist, IDragHandler, IPointerClickHandler, IEndDragHandler, IBeginDragHandler
{
    #region 变量

    public static int ValidPage;

    public static int Page;
    public static bool Flag1;
    public static bool Flag2;
    public static float RatioBk2;
    public static float RatioBk3;
    public static float RatioBk4;
    public static float RatioPlayer;
    public static float SlideSpeed;
    public static Garden Instance;
    public static Direction Direction;
    public static Transform Player;
    public static Transform GardenA;
    public static Transform GardenBk2;
    public static Transform GardenBk3;
    public static Transform GardenBk4;

    public static List<Vector3> PlayerPos = new List<Vector3>();
    public static List<Vector3> GardenPosA = new List<Vector3>();
    public static List<Vector3> GardenPosBk2 = new List<Vector3>();
    public static List<Vector3> GardenPosBk3 = new List<Vector3>();
    public static List<Vector3> GardenPosBk4 = new List<Vector3>();

    #endregion

    public override void RegistValueA()
    {
        Flag1 = true;
        Flag2 = true;
        Instance = this;

        Page = 0;
        SlideSpeed = 0.1f;

        RatioBk2 = 0.25f;
        RatioBk3 = 0.5f;
        RatioBk4 = 0.75f;
        RatioPlayer = 0.75f;

        #region Garden

        #region Cloud1

        Transform tra0 = ManaReso.Get("Cloud1");

        Tween tween = tra0.CreateTweenVec2D(new Vector3(-12, tra0.position.y, tra0.position.z), 50f, false, false, true, Curve.Linear);

        var tra1 = tra0;
        tween.OnForwardFinish += () =>
        {
            tra1.TweenForVec();
        };

        tra1.TweenForVec();

        #endregion

        #region Cloud2

        tra0 = ManaReso.Get("Cloud2");

        tween = tra0.CreateTweenVec2D(new Vector3(-12, tra1.position.y, tra1.position.z), 75f, false, false, true, Curve.Linear);

        Transform tra2 = tra0;
        tween.OnForwardFinish += () =>
        {
            tra2.TweenForVec();
        };

        tra2.TweenForVec();

        #endregion

        #region Cloud3

        tra0 = ManaReso.Get("Cloud3");

        tween = tra0.CreateTweenVec2D(new Vector3(-12, tra1.position.y, tra1.position.z), 100, false, false, true, Curve.Linear);

        tween.OnForwardFinish += () =>
        {
            tra0.TweenForVec();
        };

        tra0.TweenForVec();

        #endregion

        #region GardenA

        Move2D move2D = GardenA.CreateMove2D();

        move2D.OnForwardStart += () =>
        {
            Flag2 = false;
        };

        move2D.OnForwardFinish += () =>
        {
            Flag2 = true;
        };

        #endregion

        #region GardenMini
        
        tween = ManaReso.Get("GardenMini").CreateTweenVec2D
        (
            ManaReso.Get("PosTraMini").position,
            0.5f, 
            false,
            false, 
            true,
            Curve.EaseOutQuad
        );

        tween.OnForwardStart += () =>
        {
            ManaMiniGame.GameEnter();
        };

        tween.OnForwardFinish += () =>
        {
            ManaReso.SetActive("Player", false);
            ManaReso.SetActive("Cloud1", false);
            ManaReso.SetActive("Cloud2", false);
            ManaReso.SetActive("Cloud3", false);
            ManaReso.SetActive("GardenA", false);
            ManaReso.SetActive("GardenBk1", false);
            ManaReso.SetActive("GardenBk2", false);
            ManaReso.SetActive("GardenBk3", false);
            ManaReso.SetActive("GardenBk4", false);
        };

        tween.OnBackwardStart += () =>
        {
            ManaReso.SetActive("Player", true);
            ManaReso.SetActive("Cloud1", true);
            ManaReso.SetActive("Cloud2", true);
            ManaReso.SetActive("Cloud3", true);
            ManaReso.SetActive("GardenA", true);
            ManaReso.SetActive("GardenBk1", true);
            ManaReso.SetActive("GardenBk2", true);
            ManaReso.SetActive("GardenBk3", true);
            ManaReso.SetActive("GardenBk4", true);
        };

        tween.OnBackwardFinish += () =>
        {
            for (int i = 0; i < ManaMiniGame.IdleList.Count; i++)
            {
                ManaReso.Save(ManaMiniGame.IdleList[i]);
            }

            for (int i = 0; i < ManaMiniGame.OpList.Count; i++)
            {
                ManaReso.Save(ManaMiniGame.OpList[i]);
            }
        };

        #endregion

        #endregion
    }

    public override void RegistReference()
    {
        GardenBk2 = ManaReso.Get("GardenBk2");
        GardenBk3 = ManaReso.Get("GardenBk3");
        GardenBk4 = ManaReso.Get("GardenBk4");

        GardenA = ManaReso.Get("GardenA");

        GardenPosBk2 = new List<Vector3>()
        {
            ManaReso.Get("PageTra21").position,
            ManaReso.Get("PageTra22").position,
        };

        GardenPosBk3 = new List<Vector3>()
        {
            ManaReso.Get("PageTra31").position,
            ManaReso.Get("PageTra32").position,
        };

        GardenPosBk4 = new List<Vector3>()
        {
            ManaReso.Get("PageTra41").position,
            ManaReso.Get("PageTra42").position,
        };

        GardenPosA = new List<Vector3>()
        {
            ManaReso.Get("PageTraA").position,
            ManaReso.Get("PageTraB").position,
        };

        if (!ManaTutorial.TutorialA)
        {
            Player = ManaReso.Get("Player");
            PlayerPos = new List<Vector3>()
            {
                ManaPlayer.Player.ChildDic["PlayerTra1"].position,
                ManaPlayer.Player.ChildDic["PlayerTra2"].position,
            };
        }
    }


    public override void TutorialToRegular()
    {
        Player = ManaReso.Get("Player");
        PlayerPos = new List<Vector3>()
        {
            ManaPlayer.Player.ChildDic["PlayerTra1"].position,
            ManaPlayer.Player.ChildDic["PlayerTra2"].position,
        };
    }


    public void OnDrag(PointerEventData eventData)
    {
        if (Flag1 && Flag2)
        {
            if (Direction == Direction.Null)
            {
                if (eventData.delta.x > 0)
                {
                    Direction = Direction.Right;
                }
                else
                {
                    Direction = Direction.Left;
                }
            }
            
            if (Direction == Direction.Left)
            {
                if (eventData.delta.x > 0)
                {
                    Return();
                }
                else
                {
                    #region MyRegion

                    float rawDeltaX = eventData.position.x - eventData.pressPosition.x;

                    if (Page < ValidPage - 1)
                    {
                        float tempX = Mathf.Clamp(eventData.delta.x / 10, -2, 2) * SlideSpeed;

                        Player.Translate(Player.right * tempX * RatioPlayer, Space.World);

                        GardenA.Translate(GardenA.right * tempX, Space.World);
                        GardenBk2.Translate(GardenBk2.right * tempX * RatioBk2, Space.World);
                        GardenBk3.Translate(GardenBk3.right * tempX * RatioBk3, Space.World);
                        GardenBk4.Translate(GardenBk4.right * tempX * RatioBk4, Space.World);

                        if (rawDeltaX < -300)
                        {
                            NextPage();
                        }
                    }
                    else
                    {
                        float ratio = Mathf.Abs(GardenA.position.x - GardenPosA[ValidPage - 1].x)/0.7f;

                        float speed = Mathf.Lerp(SlideSpeed, 0, ratio);

                        float tempX = Mathf.Clamp(eventData.delta.x / 10, -2, 2) * speed;

                        GardenA.Translate(GardenA.right * tempX, Space.World);
                    }

                    #endregion
                }
            }
            else if (Direction == Direction.Right)
            {
                if (eventData.delta.x < 0)
                {
                    Return();
                }
                else
                {
                    #region MyRegion

                    float rawDeltaX = eventData.position.x - eventData.pressPosition.x;

                    if (Page > 0)
                    {
                        float tempX = Mathf.Clamp(eventData.delta.x / 10, -2, 2) * SlideSpeed;

                        Player.Translate(Player.right * tempX * RatioPlayer, Space.World);

                        GardenA.Translate(GardenA.right * tempX, Space.World);
                        GardenBk2.Translate(GardenBk2.right * tempX * RatioBk2, Space.World);
                        GardenBk3.Translate(GardenBk3.right * tempX * RatioBk3, Space.World);
                        GardenBk4.Translate(GardenBk4.right * tempX * RatioBk4, Space.World);

                        if (rawDeltaX > 300)
                        {
                            PrevPage();
                        }
                    }
                    else
                    {
                        float ratio = Mathf.Abs(GardenA.position.x - GardenPosA[0].x) / 0.7f;

                        float speed = Mathf.Lerp(SlideSpeed, 0, ratio);

                        float tempX = Mathf.Clamp(eventData.delta.x / 10, -2, 2) * speed;

                        GardenA.Translate(GardenA.right * tempX, Space.World);
                    }

                    #endregion
                }
            }
        }
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        if (Flag1 && Flag2)
        {
            Return();
        }

        Flag1 = true;
        Direction = Direction.Null;
    }

    public void OnBeginDrag(PointerEventData eventData)
    {
        Direction = Direction.Null;
    }

    public void OnPointerClick(PointerEventData eventData)
    {
        if (!eventData.hovered.Contains(eventData.rawPointerPress))
        {
            return;
        }

        if (eventData.rawPointerPress.transform.name.Contains("Slot"))
        {
            Slot slot = eventData.rawPointerPress.GetComponent<Slot>();

            if (slot.Valid == false)
            {
                Toast.Show(1.5f, Language.GetStr("Common", "UnlockSlot"));
            }
            else
            {
                ManaReso.Get("G_Flower").TweenForCG();
            }
        }
    }


    private void Return()
    {
        Flag1 = false;

        Player.Move2D(PlayerPos[Page], 0.25f, false, Curve.EaseOutQuad);
        GardenA.Move2D(GardenPosA[Page], 0.25f, false, Curve.EaseOutQuad);
        GardenBk2.Move2D(GardenPosBk2[Page], 0.25f, false, Curve.EaseOutQuad);
        GardenBk3.Move2D(GardenPosBk3[Page], 0.25f, false, Curve.EaseOutQuad);
        GardenBk4.Move2D(GardenPosBk4[Page], 0.25f, false, Curve.EaseOutQuad);
    }

    private void PrevPage()
    {
        Page--;
        
        Flag1 = false;

        Player.Move2D(PlayerPos[Page], 0.5f, false, Curve.EaseOutQuad);
        GardenA.Move2D(GardenPosA[Page], 0.5f, false, Curve.EaseOutQuad);
        GardenBk2.Move2D(GardenPosBk2[Page], 0.5f, false, Curve.EaseOutQuad);
        GardenBk3.Move2D(GardenPosBk3[Page], 0.5f, false, Curve.EaseOutQuad);
        GardenBk4.Move2D(GardenPosBk4[Page], 0.5f, false, Curve.EaseOutQuad);
    }

    private void NextPage()
    {
        Page++;
        
        Flag1 = false;

        Player.Move2D(PlayerPos[Page], 0.5f, false, Curve.EaseOutQuad);
        GardenA.Move2D(GardenPosA[Page], 0.5f, false, Curve.EaseOutQuad);
        GardenBk2.Move2D(GardenPosBk2[Page], 0.5f, false, Curve.EaseOutQuad);
        GardenBk3.Move2D(GardenPosBk3[Page], 0.5f, false, Curve.EaseOutQuad);
        GardenBk4.Move2D(GardenPosBk4[Page], 0.5f, false, Curve.EaseOutQuad);
    }
}