void DoMerge(SheepController pickUpSheep, SheepController pointSheep)
    {
        int nextSheepLevel = pickUpSheep.SheepType + 1;

        SheepController sheepEvo        = SheepFactory.Instance.CreateNewSheep(nextSheepLevel);
        SheepConfigData sheepConfigData = ConfigManager.Instance.GetSheepConfigByType(nextSheepLevel);

        sheepEvo.InitSheep(sheepConfigData.Sheepvalue, sheepConfigData.Speed);

        sheepEvo.onMoveOutOfCageDone = CloseGate;
        sheepEvo.transform.position  = pointSheep.transform.position;

        pickUpSheep.gameObject.SetActive(false);
        pointSheep.gameObject.SetActive(false);

        activeSheeps.Remove(pickUpSheep);
        activeSheeps.Remove(pointSheep);

        activeSheeps.Add(sheepEvo);

        currentSheepInCage--;
        LevelConfigData lvlConfig = ConfigManager.Instance.GetLevelConfigByLevel(DataManager.Instance.PlayerData.userLevel);

        txtLimitSheep.text = currentSheepInCage + "/" + lvlConfig.Maxsheep;
        UpdateLevel(pickUpSheep.SheepType);

        SimpleResourcesManager.Instance.ShowParticle("MergeFx", pointSheep.transform.position, 1);
    }
    void LoadSheep(List <SheepData> sheepDatas)
    {
        int sheepCount = sheepDatas.Count;

        for (int i = 0; i < sheepCount; ++i)
        {
            SheepController sheep = SheepFactory.Instance.CreateNewSheep(sheepDatas[i].sheepType);
            sheep.InitSheep(sheepDatas[i].sheepType);
            sheep.transform.position         = sheepDatas[i].position;
            sheep.transform.localEulerAngles = sheepDatas[i].localEulerAngles;
            switch ((SheepController.SheepState)sheepDatas[i].sheepState)
            {
            case SheepController.SheepState.Idle:
                currentSheepInCage++;
                break;

            case SheepController.SheepState.IsMovingOut:
                sheep.MoveOutOfCage();
                break;

            case SheepController.SheepState.Running:
                sheep.transform.localEulerAngles = new Vector3(0, 90, 0);
                sheep.transform.position         = beginPos.position;
                sheep.transform.position         = sheep.transform.position + UnityEngine.Random.Range(-3, 0) * sheep.transform.forward;
                sheep.DOMoveOnPath();
                break;

            case SheepController.SheepState.Jumping:
                sheep.DoJumpOverFence();
                break;

            case SheepController.SheepState.Picking:
                var pos = sheep.transform.position;
                pos.y = 1.8f;
                sheep.transform.position = pos;
                currentSheepInCage++;
                break;

            default:
                break;
            }
            activeSheeps.Add(sheep);
        }
    }
    private void Start()
    {
        ConfigManager.Instance.LoadConfig();
        SimpleResourcesManager.Instance.LoadResource();
        DialogManager.Instance.LoadDialog();
        DataManager.Instance.LoadData((isSuccess) =>
        {
            BoostTimer.Instance.SetUp();
            DataManager.Instance.PlayerData.userPlayTime += 1;
            currentSheepValue = DataManager.Instance.PlayerData.userSheepCoin;
            LoadSheep(DataManager.Instance.PlayerData.sheepDatas);
            string content = string.Format("<sprite>sheepIcon</sprite>{0}", BigNumbers.BigNumber.ToShortString(currentSheepValue.ToString("F0"), 4));
            txtTopCountingText.SetText(content);

            LevelConfigData lvlConfig = ConfigManager.Instance.GetLevelConfigByLevel(DataManager.Instance.PlayerData.userLevel);
            float lvlProgressVal      = DataManager.Instance.PlayerData.userExp * 1.0f / lvlConfig.Maxexp;

            txtLevelProgress.text  = "Lv. " + DataManager.Instance.PlayerData.userLevel + "- <color=white>" + (lvlProgressVal * 100).ToString("F0") + "%";
            lvlProgress.fillAmount = lvlProgressVal;

            txtLimitSheep.text = currentSheepInCage + "/" + lvlConfig.Maxsheep;

            if (DataManager.Instance.PlayerData.userLevel >= 3)
            {
                SpawnTimer.Instance.Setup();
            }

            if (isOnCutScene && DataManager.Instance.PlayerData.userPlayTime == 1)
            {
                camTarget.gameObject.SetActive(true);
                cameraHandler.enabled = false;
                cutSceneSheep.gameObject.SetActive(true);
                mainCam.GetComponent <Cinemachine.CinemachineBrain>().enabled = true;
                OpenGateLeaveSheepOut(cutSceneSheep);

                SheepConfigData sheepConfigData = ConfigManager.Instance.GetSheepConfigByType(1);
                cutSceneSheep.InitSheep(sheepConfigData.Sheepvalue, sheepConfigData.Speed);
            }
            else
            {
                Destroy(camTarget.gameObject);
                Destroy(camOverrall.gameObject);
                Destroy(camCart.transform.parent.gameObject);

                Destroy(mainCam.GetComponent <Cinemachine.CinemachineBrain>());

                cameraHandler.enabled = true;
                cutSceneSheep.gameObject.SetActive(false);

                if (DataManager.Instance.PlayerData.userPlayTime == 1)
                {
                    int initSheepCount = 1;
                    for (int i = 0; i < initSheepCount; ++i)
                    {
                        SheepController sheepController = SheepFactory.Instance.CreateNewSheep(1);
                        GameController.Instance.PutSheepBackToCage(sheepController);
                        SimpleResourcesManager.Instance.ShowParticle("MergeFx", sheepController.transform.position, 1);
                    }
                }
            }
        });
    }