// Use this for initialization
    void Start()
    {
        // -----------------------------------------
        // ------------ INITIALIZATIONS ------------
        // -----------------------------------------

        CanvasHandCursor = GameObject.Find("CanvasHandCursor");

        // Disable handcursor in execution mode TODO all disable in testmode, enable in production
        bodyManager = GameObject.Find("BodyManager");

        KinectManager = GameObject.Find("KinectManager");
        if (KinectManager == null)
        {
            return;
        }

        _kinectManager      = KinectManager.GetComponent <KinectManager>();
        _interactionManager = _kinectManager.GetComponent <InteractionManager>();

        if (CanvasHandCursor.activeSelf)
        {
            _interactionManager.enabled = false;
            CanvasHandCursor.gameObject.SetActive(false);
        }

        Debug.Log("IsUserDetected: " + _kinectManager.IsUserDetected());


        _exerciseExecutionValidationManager = ExerciseExecutionValidationManager.GetComponent <ExerciseExecutionValidationManager>();

        // Reference to exercise data of current user
//		_currentExerciseData = UserDataObject.currentUser.exerciseData[PlayerPrefs.GetInt("CurrentExerciseId")];
        _currentExerciseData = UserDataObject.GetCurrentExercise();
        _lastExercise        = UserDataObject.GetLastTierExercise();

        // Duration manager
        _durationManager = durationManager.GetComponent <DurationManager>();

        _minTimeAlreadyReached = false;
        _repsIterator          = 0;

        _methodCheckedArray = new bool[UserDataObject.GetCurrentChecksArray().Length];

        // -----------------------------------------
        // ------------- UI COMPONENTS -------------
        // -----------------------------------------

        // Exercise name
        titleText.text       = UserDataObject.GetCurrentExerciseName().ToUpper();
        standingLegText.text = UserDataObject.GetCurrentSide().direction;
        successPanel         = successPanel.GetComponent <CanvasGroup>(); // TODO implement success animation for rep

        foreach (var check in UserDataObject.GetCurrentChecksArray())
        {
            GameObject gameObjectCheckItem = Instantiate(checkItem);
            CheckItem  currentCheckItem    = gameObjectCheckItem.GetComponent <CheckItem>();

            currentCheckItem.methodName       = check.methodName;
            currentCheckItem.description.text = check.description;
            checkItemList.Add(currentCheckItem);

            gameObjectCheckItem.transform.SetParent(checkSpacer, false);
        }

        // Array of Toggles
        _toggleArray = new Toggle[UserDataObject.GetCurrentRepetitionsArray().Length];

        // Create and check toggles for each rep of current exercise
        foreach (var repetition in UserDataObject.GetCurrentRepetitionsArray())
        {
            GameObject gameObjectToggle = Instantiate(toggle);
            Toggle     currentToggle    = gameObjectToggle.GetComponent <Toggle>();

            _toggleArray[Array.IndexOf(UserDataObject.GetCurrentRepetitionsArray(), repetition)] = currentToggle;

            // Check if exercise not already accomplished
            if (!_currentExerciseData.accomplished)
            {
                // look for accomplished reps, check regarding toggles and set current rep
                if (repetition.accomplished)
                {
                    _repsIterator += 1;
                    currentToggle.GetComponent <Toggle>().isOn = true;
                }
                else if (_currentRepetition == null)
                {
                    _currentRepetition = repetition;
                }
            }
            else             // If exercise already accomplished
            {
                // Set first rep as current rep
                if (_currentRepetition == null)
                {
                    repetition.attempts   = 0;
                    repetition.confidence = 0.0f;
                    repetition.userTime   = 0.0f;

                    _currentRepetition = repetition;
                }
            }
            // Append GO to group
            gameObjectToggle.transform.SetParent(toggleGroup, false);
        }
        textReps.text = "Reps " + _repsIterator + "/" + UserDataObject.GetCurrentRepetitionsArray().Length;

        // Set ID of current repetition
        PlayerPrefs.SetInt("CurrentRepetitionId", Array.IndexOf(UserDataObject.GetCurrentRepetitionsArray(), _currentRepetition));

        // -----------------------------------------
        // ---------------- KINECT -----------------
        // -----------------------------------------

        _bodyManager = bodyManager.GetComponent <BodyManager>();
        if (_bodyManager == null)
        {
            return;
        }

        _kinectSensor = _bodyManager.GetSensor();

        _bodies = _bodyManager.GetBodies();
        Debug.Log(_bodyManager + " | " + _bodies);

        // Initialize gesture detector object
        _gestureDetectorList = new List <GestureDetector>();
        for (int bodyIndex = 0; bodyIndex < _bodies.Length; bodyIndex++)
        {
            _gestureDetectorList.Add(new GestureDetector(_kinectSensor));
        }

        // Foot joints for getting positions
        _jointFootRight           = KinectInterop.JointType.FootRight;
        _jointFootLeft            = KinectInterop.JointType.FootLeft;
        _startingHeightDifference = UserDataObject.GetCurrentExerciseStartingHeightDifference();
        heightTestIterator        = 0;

        // Initial foot position
        if (_kinectManager.IsUserDetected())
        {
            long userId = _kinectManager.GetPrimaryUserID();

            if (_kinectManager.IsJointTracked(userId, (int)_jointFootRight) &&
                _kinectManager.IsJointTracked(userId, (int)_jointFootLeft))
            {
                _initialStartingHeightLeft  = _kinectManager.GetJointKinectPosition(userId, (int)_jointFootLeft).y;
                _initialStartingHeightRight = _kinectManager.GetJointKinectPosition(userId, (int)_jointFootRight).y;

                initialLeftFootText.text  += _initialStartingHeightLeft.ToString();
                initialRightFootText.text += _initialStartingHeightRight.ToString();
            }
        }
        _bothFeetUp         = false;
        _inStartingPosition = false;


        if (UserDataObject.GetCurrentExerciseFileName() == "WalkForward")
        {
            _progressMinConfidence = 0.8f;
        }
        if (UserDataObject.GetCurrentExerciseFileName() == "BobOne")
        {
            _progressMinConfidence = 0.4f;
        }
        Debug.Log("_progressMinConfidence: " + _progressMinConfidence);
    }
Esempio n. 2
0
    // Use this for initialization
    void Start()
    {
        // Enable handcursor in execution mode
        KinectManager = GameObject.Find("KinectManager");
//		KinectManager.GetComponent<InteractionManager>().showHandCursor = true;

        _kinectManager = KinectManager.GetComponent <KinectManager>();
        if (!_kinectManager.displayUserMapSmall)
        {
            _kinectManager.displayUserMapSmall = true;
        }

        Debug.Log("Enable handcursor");

        imageConfidenceList  = new List <Image>();
        imageTimeList        = new List <Image>();
        imageAttemptsList    = new List <Image>();
        imageTimeValue       = new List <float>();
        imageConfidenceValue = new List <float>();
        imageAttemptsValue   = new List <float>();

        // Set the title of current exercise
        exerciseNameText.text = UserDataObject.GetCurrentExerciseName().ToUpper();
        textStandingLeg.text  = UserDataObject.GetCurrentSide().direction;

        // Output summary data from exercise
        OutputData();

        _currentExercise = UserDataObject.GetCurrentExercise();
        _lastExercise    = UserDataObject.GetLastTierExercise();

        Debug.Log("GetCurrentExercise: " + UserDataObject.GetCurrentExercise().fileName);
        Debug.Log("GetLastTierExercise " + UserDataObject.GetLastTierExercise().fileName);
        Debug.Log(PlayerPrefs.GetInt("CurrentExerciseId"));

        // Check if a side is not accomplished
        foreach (var side in _currentExercise.sides)
        {
            Debug.Log(side.direction);
            Debug.Log(side.accomplished);
            if (side.accomplished == false)
            {
                sideNotAccomplished = true;
            }
        }

        // Not last exercise --> load following exercise
        if (_currentExercise != _lastExercise || sideNotAccomplished)
        {
            Debug.Log("any sideNotAccomplished? : " + sideNotAccomplished);
            if (sideNotAccomplished)
            {
                buttonNextExercise.GetComponentInChildren <Text>().text = "Next Side";
                buttonNextExercise.onClick.AddListener(() =>
                {
                    Debug.Log("currentside id : " + PlayerPrefs.GetInt("CurrentSideId"));

                    if (PlayerPrefs.GetInt("CurrentSideId") == 0)
                    {
                        Debug.Log("LOAD LEFT");
                        PlayerPrefs.SetInt("CurrentSideId", 1);
                        LoadNextScene("Left");
                    }
                    else if (PlayerPrefs.GetInt("CurrentSideId") == 1)
                    {
                        Debug.Log("LOAD RIGHT");
                        PlayerPrefs.SetInt("CurrentSideId", 0);
                        LoadNextScene("Right");
                    }
                });
            }
            else             // all sides accomplished --> load next exercise
            {
                PlayerPrefs.SetInt("CurrentExerciseId", PlayerPrefs.GetInt("CurrentExerciseId") + 1);
                buttonNextExercise.onClick.AddListener(() =>
                {
                    SceneManager.LoadScene("ExerciseSideSelection");
                });
            }
        }
        else         // all exercises completed --> load TierMenu
        {
            buttonNextExercise.GetComponentInChildren <Text>().text = "Level Summary";
            buttonNextExercise.onClick.AddListener(() =>
            {
                SceneManager.LoadScene("TierSummary");
            });
        }
    }
    public void ManageNextScene()
    {
        Debug.Log("GetCurrentExercise: " + UserDataObject.GetCurrentExercise().fileName);
        Debug.Log("GetLastTierExercise: " + UserDataObject.GetLastTierExercise().fileName);
        Debug.Log("CurrentExercise ID: " + PlayerPrefs.GetInt("CurrentExerciseId"));

        // Check if a side is not accomplished
        foreach (var side in _currentExerciseData.sides)
        {
            Debug.Log("side direction: " + side.direction);
            Debug.Log("side accomplished: " + side.accomplished);
            if (side.accomplished == false)
            {
                _sideNotAccomplished = true;
            }
        }

        // Not last exercise --> load following side
        if (_currentExerciseData != _lastExercise || _sideNotAccomplished)
        {
            Debug.Log("any sideNotAccomplished? : " + _sideNotAccomplished);
            if (_sideNotAccomplished)
            {
                // TODO change subtitle of success GO

                if (PlayerPrefs.GetInt("CurrentSideId") == 0)
                {
                    Debug.Log("LOAD LEFT");
                    PlayerPrefs.SetInt("CurrentSideId", 1);
                    PlayerPrefs.SetString("CurrentSide", "Left");
                    LoadNextScene("ExerciseInfo");
                }
                else if (PlayerPrefs.GetInt("CurrentSideId") == 1)
                {
                    Debug.Log("LOAD RIGHT");
                    PlayerPrefs.SetInt("CurrentSideId", 0);
                    PlayerPrefs.SetString("CurrentSide", "Right");
                    LoadNextScene("ExerciseInfo");
                }
            }
            else             // all sides accomplished --> load next exercise
            {
                // TODO change subtitle of success GO
                UserDataObject.GetNextExercise().isInteractable = true;
                UserDataObject.GetNextExercise().unlocked       = 1;

                PlayerPrefs.SetInt("CurrentExerciseId", PlayerPrefs.GetInt("CurrentExerciseId") + 1);
                LoadNextScene("ExerciseSideSelection");
            }
        }
        else         // all exercises completed --> load TierMenu
        {
            // TODO change subtitle of success GO
            UserDataObject.GetNextTier().isInteractable = true;

            if (!UserDataObject.GetCurrentExercise().isInteractable)
            {
                UserDataObject.GetCurrentExercise().isInteractable = true;
                UserDataObject.GetCurrentExercise().unlocked       = 1;
            }


            LoadNextScene("TierMenu");
        }
        SaveCurrentExerciseData();
    }