private void MoveContainer(Type_Move tMove, Dir_Move dMove)
    {
        Container temp1 = null, temp2 = null;

        ConfigTypeMove move           = configMoves.Single((m) => m.typeMove == tMove);
        pathContainer  pathsContainer = splinePaths.Single((s) => s.typeMove == tMove);

        temp1 = arrContainers[move.posObj1];
        temp2 = arrContainers[move.posObj2];

        pathContainer.Path path_1;
        pathContainer.Path path_2;

        // Obtener path de acuerdo a la direccion
        path_1 = pathsContainer.arrPathMovement.Single((p) => p.namePath == ((dMove == Dir_Move.Right) ? "Up" : "Down"));
        path_2 = pathsContainer.arrPathMovement.Single((p) => p.namePath == ((dMove == Dir_Move.Right) ? "Down" : "Up"));

        // Obtener el spline que recorrera el contenedor
        // El segundo container siempre tendra el path inverso
        LTSpline spline_1 = GetSplineFromTranform(path_1.arrPath, false);
        LTSpline spline_2 = GetSplineFromTranform(path_2.arrPath, true);

        // Mover contenedores

        // cantidad de contenedores que se moveran.
        _countContainersMoving = 2;

        // Calcular velocidad. Velocidad de cada movimiento obtenida desde el arreglo multiplicado
        // por la dificultad del juego.
        currVelocityShuffle = velSingleShuffle[_countMoves - 1] * difficulty;

        arrContainers[move.posObj1].Move(spline_1, currVelocityShuffle, () =>
        {
            _countContainersMoving--;

            if (_countContainersMoving <= 0)
            {
                FinishMove();
            }
        });

        arrContainers[move.posObj2].Move(spline_2, currVelocityShuffle, () =>
        {
            _countContainersMoving--;

            if (_countContainersMoving <= 0)
            {
                FinishMove();
            }
        });

        arrContainers[move.posObj1] = temp2;
        arrContainers[move.posObj2] = temp1;

        spline_1       = null;
        spline_2       = null;
        pathsContainer = null;
        temp1          = null;
        temp2          = null;
    }
    /// <summary>
    /// Inicializar minijuego
    /// </summary>
    public void InitGame()
    {
        if (isShuffling)
        {
            return;
        }

        // Reiniciar posicion de contenedores
        for (int i = 0; i < posContainers.Length; i++)
        {
            // Obtener el orden de cada contenedor (pos init) y cambiar la posicion del objeto
            // de acuerdo a su posicion inicial.
            arrContainers[i].transform.position = posContainers[arrContainers[i].GetInitPos()].position;
        }

        // Ordenar arreglo de acuerdo a su posicion inicial
        arrContainers = arrContainers.OrderBy((c) => c.initPos).ToArray();

        _countMoves        = 0;
        _currDirMove       = Dir_Move.None;
        _currTypeMove      = Type_Move.None;
        isShuffling        = true;
        canNextMove        = true;
        canSelectContainer = false;

        OnInitGame.Invoke();

        Invoke("Shuffle", .2f);
    }
    /// <summary>
    /// Revolver contenedores
    /// </summary>
    public void Shuffle()
    {
        if (_countMoves >= maxMoves)
        {
            return;
        }

        if (!canNextMove)
        {
            return;
        }

        OnInitMove.Invoke();

        canNextMove = false;

        _countMoves++;

        // Obtener direccion movimiento
        int dirMove = UnityEngine.Random.Range(1, Enum.GetNames(typeof(Dir_Move)).Length);

        _currDirMove = (Dir_Move)dirMove;

        // Obtener tipo de movimiento
        int typeMove = (int)_currTypeMove;

        // Evitar repetir el movimiento anterior
        while (typeMove == (int)_currTypeMove)
        {
            typeMove = UnityEngine.Random.Range(1, Enum.GetNames(typeof(Type_Move)).Length);
        }

        _currTypeMove = (Type_Move)typeMove;

        // Revolver contenedores
        //Move_1: Intercambio entre posicion 1 y posicion 2
        //Move_2: Intercambio entre posicion 1 y posicion 3
        //Move_3: Intercambio entre posicion 2 y posicion 3
        MoveContainer(_currTypeMove, _currDirMove);
    }