QuizDisplay.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using PixoVR.Vrinput;
using PixoVR.Audio;
using PixoVR.Core;
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using UnityEngine.EventSystems;
using PixoVR.Apex;
using PixoVR.Apex.XAPI;
using Scripts.UI.UIPositioningSystem;
using TinCan;
 
namespace PixoVR.Event
{
    public class QuizDisplay : InteractableClass
    {
        [Space] [SerializeField] private CanvasGroup _canvasGroup;
        [SerializeField] private NearWaypoint _nearWaypoint;
        [SerializeField] private QuizData _quizData;
        [SerializeField] private TMP_Text _questionText;
        [SerializeField] private AnswerOption[] _answerOptions;
        [SerializeField] private Button _confirmButton;
        [SerializeField] private TMP_Text _confirmText;
        [SerializeField] private TMP_Text singleText;
        [SerializeField] private string sfxCorrectAnswer;
        [SerializeField] private string sfxIncorrectAnswer;
        [SerializeField] private string sfxFixBrokenItem;
        [SerializeField] private string sfxClick;
        [SerializeField] private GameObject[] _additionalItemsToEnable;
        [SerializeField] private List<VisibilityControlPoint> _visibilityControlPoints;
 
        [SerializeField] private int currentQuestionIndex;
        [Space] [SerializeField] private bool _objectsShouldBeRepaired = false;
        [SerializeField] private bool _correectAnswerShouldBeCleanedForNone = false;
        [SerializeField] private bool _useNearWaypoint = false;
 
        private Quiz _currentQuiz;
        private string _selectedAnswer;
        private InteractableClass _itemInQuestion;
        private ItemsEnum _itemIdInQuestion;
        private bool _isItemBroken;
        private int _brokenID;
        private bool _isShouldWaitForEndingVO = false;
 
        private bool _isSelectedCorrectAnswer;
        private bool _isAnswerSaved = false;
        [Space] public int _selectedAnswerOptionID;
 
        private AudioService _audioService;
        private StepManager _stepManager;
        private ApexSessionState _apexSessionState;
 
        private void Start()
        {
            _audioService = ServiceLocator.Resolve<AudioService>();
            _stepManager = ServiceLocator.Resolve<StepManager>();
            _quizData = StatesService.GetState<QuizData>();
            _apexSessionState = StatesService.GetState<ApexSessionState>(true);
 
            ClearAnswersHistory();
            EnableAdditionalItems(false);
        }
 
        private void SubscribeOnToggles()
        {
            for (int i = 0; i < _answerOptions.Length; i++)
            {
                _answerOptions[i].ToggleSelected += OnToggleSelected;
                _answerOptions[i].toggleID = i;
            }
        }
 
        private void UnsubscribeOnToggles()
        {
            for (int i = 0; i < _answerOptions.Length; i++)
            {
                _answerOptions[i].ToggleSelected -= OnToggleSelected;
            }
        }
 
        private void ClearAnswersHistory()
        {
            foreach (var quiz in _quizData.ListOfQuizzes)
            {
                foreach (var question in quiz.Questions)
                {
                    question.ClearAnswers();
                }
            }
        }
 
        private void OnConfirmButtonClick()
        {
            PlayAudio();
            UpdateStepManager();
        }
 
        private void UpdateStepManager()
        {
            _confirmButton.interactable = false;
 
            var questionInformation = _currentQuiz.Questions[currentQuestionIndex];
 
            if (!IsLastQuestion())
            {
                if (!_isAnswerSaved)
                {
                    _isAnswerSaved = true;
                    questionInformation.SetSelectedAnswer(_selectedAnswer);
                }
 
                if (_isSelectedCorrectAnswer)
                {
                    if (_itemIdInQuestion != ItemsEnum.NONE)
                    {
                        if (_objectsShouldBeRepaired)
                        {
                            RepairObject(questionInformation.BreakableObjectID);
                        }
                        else
                        {
                            SetInspectedMark(questionInformation.BreakableObjectID);
                        }
                    }
 
                    _isAnswerSaved = false;
                    currentQuestionIndex++;
 
                    SetQuestionInformation();
                }
                else
                {
                    EventSystem.current.SetSelectedGameObject(null);
                }
            }
 
            else
            {
                if (!_isAnswerSaved)
                {
                    _isAnswerSaved = true;
                    questionInformation.SetSelectedAnswer(_selectedAnswer);
                }
 
                if (_isSelectedCorrectAnswer)
                {
                    if (_itemIdInQuestion != ItemsEnum.NONE)
                    {
                        if (_objectsShouldBeRepaired)
                        {
                            RepairObject(questionInformation.BreakableObjectID);
                        }
 
                        else
                        {
                            SetInspectedMark(questionInformation.BreakableObjectID);
                        }
                    }
 
                    _isAnswerSaved = false;
 
                    if (!_isShouldWaitForEndingVO)
                    {
                        Hide();
                    }
                }
                else
                {
                    EventSystem.current.SetSelectedGameObject(null);
                }
            }
 
            SendApexEvents(questionInformation);
        }
 
        private void SendApexEvents(QuestionInformation questionInformation)
        {
            if (!_apexSessionState.IsLoggedIn) return;
 
            var eventData = new Dictionary<string, string>
            {
                { "Time", $"{DateTime.UtcNow}" },
                { "Question", $"{questionInformation.Question}" },
                { "Correct Answer", $"{questionInformation.GetCorrectAnswer()}" },
                { "Given Answer", $"{questionInformation.GetSelectedAnswer()}" },
                { "Earned Score", $"{questionInformation.GetEarnedScoring()}" },
                { "Max Score", $"{questionInformation.Scoring}" }
            };
 
            ApexSystem.SendSimpleSessionEvent("Custom event", "",
                new Extension(eventData));
        }
 
        private bool IsLastQuestion()
        {
            return currentQuestionIndex == _currentQuiz.Questions.Count - 1;
        }
 
        private void OnToggleSelected(string selectedAnswer, bool isCorrect, int optionID)
        {
            _audioService.PlayFX(sfxClick);
            _selectedAnswer = selectedAnswer;
            _isSelectedCorrectAnswer = isCorrect;
            _confirmButton.interactable = true;
 
            if (_selectedAnswerOptionID == optionID) return;
 
            if (_selectedAnswerOptionID < _answerOptions.Length)
            {
                _answerOptions[_selectedAnswerOptionID].SetSelected(false);
            }
 
            _selectedAnswerOptionID = optionID;
        }
 
        private void RepairObject(ItemsEnum itemId)
        {
            _stepManager.GetGameObjectByID(itemId).RepairElement();
        }
 
        private void SetInspectedMark(ItemsEnum itemId)
        {
            _stepManager.GetGameObjectByID(itemId).SetInspected();
        }
 
        private void SetQuestionInformation()
        {
            _confirmButton.interactable = false;
            SetQuestionText(_currentQuiz.Questions[currentQuestionIndex].Question);
            SetAnswersOptions(_currentQuiz.Questions[currentQuestionIndex]);
        }
 
        private void SetAnswersOptions(QuestionInformation questionInformation)
        {
            var optionsAnswers = questionInformation.OptionsAnswers;
            _itemIdInQuestion = questionInformation.BreakableObjectID;
            var VO_Description = questionInformation.VO_ID_DescriptionForAnswer;
            if (VO_Description != string.Empty)
            {
                PlayFeedbackVoiceOver(VO_Description);
            }
 
            _isItemBroken = false;
 
            if (_itemIdInQuestion != ItemsEnum.NONE)
            {
                _itemInQuestion = _stepManager.GetGameObjectByID(_itemIdInQuestion);
                _isItemBroken = _itemInQuestion.IsBroken;
                _brokenID = _itemInQuestion.BrokenId;
            }
 
            // var correctAnswers = _isItemBroken
            //     ? questionInformation.CorrectAnswerID_Broken
            //     : questionInformation.CorrectAnswerID_IfNotBroken;
 
            List<int> correctAnswers;
            if (_isItemBroken)
            {
                if (_brokenID == 0)
                {
                    correctAnswers = questionInformation.CorrectAnswerID_Broken;
                }
                else
                {
                    correctAnswers = questionInformation.CorrectAnswersID_AdditionalBroken[_brokenID - 1].Answers;
                }
            }
            else
            {
                correctAnswers = questionInformation.CorrectAnswerID_IfNotBroken;
            }
 
            for (int i = 0; i < _answerOptions.Length; i++)
            {
                _answerOptions[i].gameObject.SetActive(true);
 
                if (i < optionsAnswers.Count)
                {
                    _answerOptions[i].SetSelected(false);
                    _answerOptions[i].SetText(optionsAnswers[i]);
                    _answerOptions[i].SetCorrectnes(false);
                }
 
                else
                {
                    _answerOptions[i].gameObject.SetActive(false);
                }
            }
 
            foreach (var answer in correctAnswers)
            {
                var answers = questionInformation.OptionsAnswers;
                _currentQuiz.Questions[currentQuestionIndex].SetCorrectAnswer(answers[answer]);
                _answerOptions[answer].SetCorrectnes(true);
            }
        }
 
        private void PlayFeedbackVoiceOver(string idVo, bool isLastQuestion = true, bool isVoMustFinished = false)
        {
            if (isVoMustFinished)
            {
                _isShouldWaitForEndingVO = true;
                _canvasGroup.interactable = false;
                _confirmButton.interactable = false;
                if (isLastQuestion)
                {
                    _audioService.RepeatableAudioStopped += Hide;
                }
                else
                {
                    _audioService.RepeatableAudioStopped += () =>
                    {
                        _isShouldWaitForEndingVO = false;
                        _canvasGroup.interactable = true;
                    };
                }
            }
            else
            {
                _isShouldWaitForEndingVO = false;
            }
 
            EventBetter.Raise(new GuideVoiceOverPlayEvent()
            {
                VoiceOverName = idVo
            });
 
            _audioService.PlayRepeatable(idVo);
        }
 
        private void SetQuestionText(string questionText)
        {
            _questionText.SetText(questionText);
        }
 
        private void PlayAudio()
        {
            _audioService.StopAllVoiceOvers();
 
            var scenarioState = StatesService.GetState<ScenarioState>();
 
            var questionInformation = _currentQuiz.Questions[currentQuestionIndex];
 
            if (_itemInQuestion == null ||
                (_itemIdInQuestion == ItemsEnum.NONE
                 && _correectAnswerShouldBeCleanedForNone))
            {
                if (_isSelectedCorrectAnswer)
                {
                    _audioService.PlayFX(sfxCorrectAnswer);
 
                    if (questionInformation.VO_ID_RightAnswer_NotBroken == string.Empty
                        || scenarioState.IsEvaluation) return;
 
                    PlayFeedbackVoiceOver(questionInformation.VO_ID_RightAnswer_NotBroken, IsLastQuestion(), true);
                }
                else
                {
                    _audioService.PlayFX(sfxIncorrectAnswer);
 
                    if (questionInformation.VO_ID_Incorrect_NotBroken == string.Empty
                        || scenarioState.IsEvaluation) return;
                    
                    PlayFeedbackVoiceOver(questionInformation.VO_ID_Incorrect_NotBroken);
                }
            }
 
            else
            {
                if (_isItemBroken)
                {
                    if (_isSelectedCorrectAnswer)
                    {
                        _audioService.PlayFX(sfxCorrectAnswer);
 
                        if ((questionInformation.VO_ID_RightAnswerBroken == string.Empty && _brokenID == 0)
                            || (_brokenID > 0 &&
                                questionInformation.VO_ID_RightAnswersAdditionalBroken[_brokenID - 1] == string.Empty)
                            || scenarioState.IsEvaluation)
                        {
                            if (_objectsShouldBeRepaired)
                            {
                                _audioService.PlayFX(sfxFixBrokenItem);
                            }
                        }
                        else
                        {
                            PlayFeedbackVoiceOver(
                                _brokenID == 0
                                    ? questionInformation.VO_ID_RightAnswerBroken
                                    : questionInformation.VO_ID_RightAnswersAdditionalBroken[_brokenID - 1],
                                IsLastQuestion(),
                                true);
 
                            if (_objectsShouldBeRepaired)
                            {
                                _audioService.PlayFX(sfxFixBrokenItem);
                            }
                        }
                    }
                    else
                    {
                        _audioService.PlayFX(sfxIncorrectAnswer);
 
                        if ((questionInformation.VO_ID_Incorrect_Broken == string.Empty && _brokenID == 0) ||
                            (_brokenID > 0 && questionInformation.VO_ID_Incorrect_AdditionalBroken[_brokenID - 1] ==
                                string.Empty)
                            || scenarioState.IsEvaluation) return;
 
                        PlayFeedbackVoiceOver(_brokenID == 0
                            ? questionInformation.VO_ID_Incorrect_Broken
                            : questionInformation.VO_ID_Incorrect_AdditionalBroken[_brokenID - 1]);
                    }
                }
                else
                {
                    if (_isSelectedCorrectAnswer)
                    {
                        _audioService.PlayFX(sfxCorrectAnswer);
 
                        if (questionInformation.VO_ID_RightAnswer_NotBroken == string.Empty
                            || scenarioState.IsEvaluation) return;
 
                        PlayFeedbackVoiceOver(questionInformation.VO_ID_RightAnswer_NotBroken, IsLastQuestion(),
                            true);
                    }
                    else
                    {
                        _audioService.PlayFX(sfxIncorrectAnswer);
 
                        if (questionInformation.VO_ID_Incorrect_NotBroken == string.Empty
                            || scenarioState.IsEvaluation) return;
 
                        PlayFeedbackVoiceOver(questionInformation.VO_ID_Incorrect_NotBroken);
                    }
                }
            }
        }
 
        private void Hide()
        {
            _isShouldWaitForEndingVO = false;
 
            EventBetter.Raise(new TriggeredItemEvent()
            {
                item = ItemId
            });
 
            _audioService.RepeatableAudioStopped -= Hide;
            _confirmButton.interactable = false;
 
            Interactive(false);
 
 
            _visibilityControlPoints?.ForEach(x => x.enabled = false);
        }
 
        public override void OpenInspectionMenu(string quizID)
        {
            _confirmButton.interactable = false;
            Interactive(true);
            currentQuestionIndex = 0;
 
            _currentQuiz = _quizData.GetQuizItem(quizID);
 
            var firstQuestion = _currentQuiz.Questions[0];
 
            SetQuestionText(firstQuestion.Question);
            SetAnswersOptions(firstQuestion);
        }
 
 
        public override void Interactive(bool isInteractive)
        {
            bool isAlreadySubscribe = IsActive;
            IsActive = isInteractive;
            _canvasGroup.alpha = isInteractive ? 1 : 0;
            _canvasGroup.blocksRaycasts = isInteractive;
            _canvasGroup.interactable = isInteractive;
 
            EnableAdditionalItems(isInteractive);
 
            _visibilityControlPoints?.ForEach(x => x.enabled = isInteractive);
 
            if (isInteractive && !isAlreadySubscribe)
            {
                SubscribeOnToggles();
 
                _confirmButton.onClick.AddListener(OnConfirmButtonClick);
            }
 
            else if (!isInteractive)
            {
                UnsubscribeOnToggles();
 
                _confirmButton.onClick.RemoveListener(OnConfirmButtonClick);
            }
 
            if (isInteractive && _useNearWaypoint)
            {
                _nearWaypoint.CheckNearestPoint();
            }
        }
        
        private void EnableAdditionalItems(bool isActive)
        {
            if (_additionalItemsToEnable != null && _additionalItemsToEnable.Length > 0)
            {
                foreach (var go in _additionalItemsToEnable)
                {
                    go.SetActive(isActive);
                }
            }
        }
 
        public override void SetParametersForItem(string quizId, string[] additionalValues)
        {
            _currentQuiz = _quizData.GetQuizItem(quizId);
            var firstQuestion = _currentQuiz.Questions[0];
            
            firstQuestion.SetCorrectAnswer(additionalValues[0]);
            firstQuestion.SetSelectedAnswer(additionalValues[1]);
            
            SetInspectedMark(firstQuestion.BreakableObjectID);
        }
    }
}