public void SetPipeAnswers(IEnumerable <ILivingLetterData> wrongAnswers, ILivingLetterData correctAnswers, bool sunMoonQuestion)
{
// Selecting auto-hiding signs
toHide.Clear();
for (int i = 0; i < pipeAnswers.Length; ++i)
{
if (Random.value + 0.0001f < hidingProbability)
{
toHide.Add(pipeAnswers[i]);
}
}
hideSignsTimer = 1.5f + 0.5f * toHide.Count;
HidePipes();
currentPipeAnswer = null;
List <ILivingLetterData> wrongs = new List <ILivingLetterData>();
foreach (ILivingLetterData answer in wrongAnswers)
{
wrongs.Add(answer);
}
int answersCount = wrongs.Count + 1;
if (answersCount > 4)
{
answersCount = 4;
}
if (sunMoonQuestion)
{
int correctIndex = 0;
int wrongIndex = 1;
if (correctAnswers.Id == "the_sun")
{
correctIndex = 1;
wrongIndex = 0;
}
pipeAnswers[correctIndex].SetAnswer(correctAnswers, true, game.drawingMaterial, Color.black);
pipeAnswers[correctIndex].active = true;
pipeAnswers[correctIndex].ShowSign = true;
pipeAnswers[wrongIndex].SetAnswer(wrongs[0], false, game.drawingMaterial, Color.black);
pipeAnswers[wrongIndex].active = true;
pipeAnswers[wrongIndex].ShowSign = true;
}
else
{
int correctPosition = Random.Range(0, answersCount);
for (int i = 0; i < answersCount; i++)
{
if (i == correctPosition)
{
pipeAnswers[i].SetAnswer(correctAnswers, true,
ToboganGame.I.Difficulty <= 0.1f ? game.markedTextMaterial : game.textMaterial,
ToboganGame.I.Difficulty <= 0.1f ? (Color)ToboganGame.LETTER_MARK_PIPE_COLOR : Color.black);
}
else
{
int wrongIndex = Random.Range(0, wrongs.Count);
pipeAnswers[i].SetAnswer(wrongs[wrongIndex], false, game.textMaterial, Color.black);
wrongs.RemoveAt(wrongIndex);
}
pipeAnswers[i].active = true;
pipeAnswers[i].ShowSign = true;
}
}
}
public EggLivingLetter(Transform parent, GameObject letterObjectViewPrefab, GameObject shadowPrefab, ILivingLetterData livingLetterData, Vector3 startPosition, Vector3 shadowPosition, Vector3 endPosition, float delay, Action endCallback)
{
livingLetter = UnityEngine.Object.Instantiate(letterObjectViewPrefab).GetComponent <LivingLetterController>();
livingLetter.transform.SetParent(parent);
livingLetter.transform.localPosition = startPosition;
if (livingLetterData.DataType == LivingLetterDataType.Letter)
{
((LL_LetterData)livingLetterData).ForceShowAccent = true;
}
livingLetter.Init(livingLetterData);
livingLetter.transform.localScale *= startScale;
livingLetter.gameObject.SetActive(false);
if (EggConfiguration.Instance.Variation == EggVariation.Image)
{
livingLetter.TransformIntoImage();
}
shadowTransform = UnityEngine.Object.Instantiate(shadowPrefab).transform;
shadowTransform.SetParent(parent);
shadowLocalPosition = shadowPosition;
shadowTransform.localPosition = shadowLocalPosition;
shadowTransform.localScale *= 0.7f;
shadowTransform.gameObject.SetActive(false);
this.startPosition = startPosition;
this.endPosition = endPosition;
this.delay = delay;
this.endCallback = endCallback;
JumpToEnd();
}
public IEnumerator StartNewRound_LettersInWord()
{
IQuestionPack newQuestionPack = ThrowBallsConfiguration.Instance.Questions.GetNextQuestion();
List <ILivingLetterData> letterData = newQuestionPack.GetCorrectAnswers().ToList();
numLettersRemaining = letterData.Count;
numLetters = numLettersRemaining;
ResetScene();
if (roundNumber == 1)
{
MinigamesUI.Init(MinigamesUIElement.Lives | MinigamesUIElement.Starbar);
MinigamesUI.Lives.Setup(MAX_NUM_BALLS);
}
UIController.instance.Enable();
ILivingLetterData firstLetter = letterData[0];
letterData.RemoveAt(0);
List <ILivingLetterData> remainingLetters = letterData;
question = newQuestionPack.GetQuestion();
UIController.instance.SetLetterHint(question);
SayQuestion();
yield return(new WaitForSeconds(1f));
int numLettersInRound = remainingLetters.Count + 1;
for (int i = 0; i < numLettersInRound; i++)
{
GameObject letterObj = letterPool[i];
letterObj.SetActive(true);
letterControllers[i].SetMotionVariation(GetMotionOfRound());
letterControllers[i].SetPropVariation(GetPropOfRound());
if (i == 0)
{
letterObj.tag = Constants.TAG_CORRECT_LETTER;
letterControllers[i].SetLetter(firstLetter);
}
else
{
if (remainingLetters[0].Id == firstLetter.Id)
{
letterObj.tag = Constants.TAG_CORRECT_LETTER;
}
else
{
letterObj.tag = Constants.TAG_WRONG_LETTER;
}
letterControllers[i].SetLetter(remainingLetters[0]);
remainingLetters.RemoveAt(0);
}
}
isRoundOngoing = true;
BallController.instance.Enable();
if (IsTutorialLevel())
{
switch (ThrowBallsConfiguration.Instance.Variation)
{
case ThrowBallsVariation.letters:
audioManager.PlayDialogue(Db.LocalizationDataId.ThrowBalls_letters_Tuto);
break;
case ThrowBallsVariation.words:
audioManager.PlayDialogue(Db.LocalizationDataId.ThrowBalls_words_Tuto);
break;
case ThrowBallsVariation.lettersinword:
audioManager.PlayDialogue(Db.LocalizationDataId.ThrowBalls_letterinword_Tuto);
break;
default:
break;
}
inputManager.Enabled = true;
isVoiceOverDone = true;
ShowTutorialUI();
}
}
/// <summary>
/// Initializes object with the specified data.
/// </summary>
/// <param name="data">The data.</param>
public void Init(ILivingLetterData data)
{
idleTimer = Random.Range(3, 8);
Data = data;
}
public void DisplayText(ILivingLetterData _letterData)
{
letterData = _letterData;
LetterText.SetLetterData(letterData);
}
public void Init(ILivingLetterData _data)
{
letterData = _data;
LLPrefab.Init(_data);
ConfigureJointAnchors(_data);
}
public void LogAnswer(ILivingLetterData data, bool isCorrect)
{
Context.GetLogManager().OnAnswered(data, isCorrect);
//Debug.Log(data.TextForLivingLetter);
}
void Update()
{
if (lLDAudioQuestion.Count > 0)
{
if (audioSource != null)
{
if (!audioSource.IsPlaying)
{
audioSource = null;
}
}
else
{
ILivingLetterData letterData = lLDAudioQuestion[0];
audioSource = audioManager.PlayVocabularyData(letterData, false);
lLDAudioQuestion.RemoveAt(0);
}
}
else
{
if (audioSource != null)
{
if (!audioSource.IsPlaying)
{
audioSource = null;
if (endAudioQuestion != null)
{
endAudioQuestion();
}
}
}
}
if (!eggEggCrackCompleteSent)
{
if (piecePoofCompleteCount >= eggPieces.Length)
{
eggEggCrackCompleteSent = true;
EggShow(false);
if (onEggCrackComplete != null)
{
onEggCrackComplete();
}
}
}
if (emoticonsController != null)
{
emoticonsController.Update(Time.deltaTime);
}
for (int i = 0; i < eggLivingLetters.Count; i++)
{
eggLivingLetters[i].Update(Time.deltaTime);
}
}
public void SetQuestion(ILivingLetterData _questionData)
{
questionData = _questionData;
}
private Answer GenerateCorrectAnswer(ILivingLetterData correctAnswer)
{
cacheAnswerToRead = correctAnswer;
return(ItemFactory.Instance.SpawnAnswer(correctAnswer, true, dialogues));
}
public void OnEggButtonPressed(ILivingLetterData letterData)
{
game.Context.GetAudioManager().PlaySound(Sfx.UIButtonClick);
if (Time.realtimeSinceStartup - lastTimePressed > deltaPressedInterval)
{
game.Context.GetAudioManager().PlayVocabularyData(letterData, false);
}
lastTimePressed = Time.realtimeSinceStartup;
if (showTutorial)
{
if (!enteredRepeatMode)
{
TutorialUI.Clear(false);
}
tutorialDelayTimer = tutorialDelayTime;
tutorialCorrectActive = false;
}
if (letterData == game.CurrentQuestion.Letters[letterOnSequence])
{
if (isSequence)
{
game.eggButtonBox.GetEggButton(letterData).SetPressed();
PositiveFeedback();
game.Context.GetLogManager().OnAnswered(letterData, true);
}
else
{
repeatInputHasProgressed = true;
if (!enteredRepeatMode)
{
EggConfiguration.Instance.Context.GetAudioManager().PlaySound(Sfx.OK);
enteredRepeatMode = true;
game.HintButton.gameObject.SetActive(false);
Vector3 clickPosition = game.eggButtonBox.GetButtons(false)[0].transform.position;
TutorialUI.ClickRepeat(clickPosition, 4);
game.eggButtonBox.RemoveButtons((a) => { return(a != letterData); });
if (!showTutorial)
{
game.Context.GetLogManager().OnAnswered(letterData, true);
}
}
}
}
else
{
if (isSequence && game.eggButtonBox.GetEggButton(letterData).IsPressed())
{
return;
}
game.eggButtonBox.SetButtonsOnStandardColor(game.eggButtonBox.GetEggButton(letterData));
if (showTutorial)
{
ShowTutorialPressedWrong(letterData);
}
else
{
NegativeFeedback();
game.Context.GetLogManager().OnAnswered(letterData, false);
}
}
}
private Answer GenerateWrongAnswer(ILivingLetterData wrongAnswer)
{
return(ItemFactory.Instance.SpawnAnswer(wrongAnswer, false, dialogues));
}
public IQuestion GetNextQuestion()
{
if (state != QuestionGeneratorState.Initialized)
{
throw new InvalidOperationException("Not Initialized");
}
state = QuestionGeneratorState.QuestionFeeded;
currentPack = provider.GetNextQuestion();
if (config == DefaultQuestionType.MissingForm || config == DefaultQuestionType.VisibleForm)
{
return(CustomQuestion());
}
List <Answer> answers = new List <Answer>();
ILivingLetterData questionData = currentPack.GetQuestion();
//____________________________________
//Prepare answers for next method call
//____________________________________
foreach (var wrong in currentPack.GetWrongAnswers())
{
var wrongAnsw = GenerateWrongAnswer(wrong);
answers.Add(wrongAnsw);
totalAnswers.Add(wrongAnsw);
}
int correctCount = 0;
Answer greenAnswerLetter = null;
foreach (var correct in currentPack.GetCorrectAnswers())
{
var correctAnsw = GenerateCorrectAnswer(correct);
if (correctCount == 0)
{
greenAnswerLetter = correctAnsw;
}
correctCount++;
answers.Add(correctAnsw);
totalAnswers.Add(correctAnsw);
}
partialAnswers = answers.ToArray();
// Generate the question
var question = GenerateQuestion(questionData, correctCount);
totalQuestions.Add(question);
greenHighlightList.Add(new Tuple <IQuestion, Answer>(question, greenAnswerLetter));
// Generate placeholders
foreach (var correct in currentPack.GetCorrectAnswers())
{
GeneratePlaceHolder(question, AssessmentOptions.Instance.AnswerType);
}
return(question);
}
public virtual bool IsDataMatching(ILivingLetterData data1, ILivingLetterData data2)
{
return(DataMatchingHelper.IsDataMatching(data1, data2, LetterEqualityStrictness.LetterOnly));
}
private Answer GenerateWrongAnswer(ILivingLetterData wrongAnswer)
{
return(ItemFactory.Instance.SpawnAnswer(wrongAnswer, false, audioManager));
}
public void SetAnswers(ILivingLetterData _answersData)
{
answersData.Clear();
answersData.Add(_answersData);
}
private Answer GenerateCorrectAnswer(ILivingLetterData correctAnswer)
{
return(ItemFactory.Instance.SpawnAnswer(correctAnswer, true, audioManager));
}
public IEnumerator StartNewRound()
{
ResetScene();
if (!uiInitialised && !IsTutorialRound())
{
uiInitialised = true;
game.Context.GetOverlayWidget().Initialize(true, false, true);
game.Context.GetOverlayWidget().SetStarsThresholds(1, 3, 5);
game.Context.GetOverlayWidget().SetMaxLives(MAX_NUM_BALLS);
}
IQuestionPack newQuestionPack = ThrowBallsConfiguration.Instance.Questions.GetNextQuestion();
question = newQuestionPack.GetQuestion();
ILivingLetterData correctDatum = newQuestionPack.GetCorrectAnswers().ToList()[0];
List <ILivingLetterData> wrongData = newQuestionPack.GetWrongAnswers().ToList();
if (ThrowBallsConfiguration.Instance.Variation == ThrowBallsVariation.Word)
{
correctDatum = new LL_ImageData(correctDatum.Id);
for (int i = 0; i < wrongData.Count; i++)
{
wrongData[i] = new LL_ImageData(wrongData[i].Id);
}
}
else
{
SayQuestion();
}
yield return(new WaitForSeconds(1f));
int indexOfCorrectLetter = 0;
if (game.Difficulty <= ThrowBallsGame.ThrowBallsDifficulty.Easy || IsTutorialRound())
{
for (int i = 0; i < NumLettersInCurrentRound; i++)
{
letterPool[i].SetActive(true);
}
int indexOfUnobstructedLetter = 0;
while (letterControllers[indexOfUnobstructedLetter].IsObstructedByOtherLetter())
{
indexOfUnobstructedLetter++;
}
indexOfCorrectLetter = indexOfUnobstructedLetter;
}
for (int i = 0; i < NumLettersInCurrentRound; i++)
{
GameObject letterObj = letterPool[i];
letterObj.SetActive(true);
ConfigureLetterPropAndMotionVariation(letterControllers[i]);
if (i == indexOfCorrectLetter)
{
letterObj.tag = Constants.CORRECT_LETTER_TAG;
letterControllers[i].SetLetter(correctDatum);
tutorialTarget = letterObj;
}
else
{
letterObj.tag = Constants.WRONG_LETTER_TAG;
letterControllers[i].SetLetter(wrongData[0]);
wrongData.RemoveAt(0);
}
}
isRoundOngoing = true;
BallController.instance.Enable();
UIController.instance.Enable();
UIController.instance.EnableLetterHint();
UIController.instance.SetLivingLetterData(question);
if (IsTutorialRound())
{
switch (ThrowBallsConfiguration.Instance.Variation)
{
case ThrowBallsVariation.LetterName:
audioManager.PlayDialogue(Database.LocalizationDataId.ThrowBalls_lettername_Tuto);
break;
case ThrowBallsVariation.LetterAny:
audioManager.PlayDialogue(Database.LocalizationDataId.ThrowBalls_lettername_Tuto);
break;
case ThrowBallsVariation.Word:
audioManager.PlayDialogue(Database.LocalizationDataId.ThrowBalls_word_Tuto);
break;
case ThrowBallsVariation.BuildWord:
audioManager.PlayDialogue(Database.LocalizationDataId.ThrowBalls_buildword_Tuto);
break;
default:
throw new ArgumentOutOfRangeException();
}
inputManager.Enabled = true;
isVoiceOverDone = true;
ShowTutorialUI();
}
}
public EggLivingLetter(Transform parent, GameObject letterObjectViewPrefab, GameObject shadowPrefab, ILivingLetterData livingLetterData, Vector3 startPosition, Vector3 shadowPosition, Vector3 endPosition, float delay, Action endCallback)
{
livingLetter = UnityEngine.Object.Instantiate(letterObjectViewPrefab).GetComponent <LivingLetterController>();
livingLetter.transform.SetParent(parent);
livingLetter.transform.localPosition = startPosition;
livingLetter.Init(livingLetterData);
livingLetter.transform.localScale *= startScale;
livingLetter.gameObject.SetActive(false);
shadowTransform = UnityEngine.Object.Instantiate(shadowPrefab).transform;
shadowTransform.SetParent(parent);
shadowLocalPosition = shadowPosition;
shadowTransform.localPosition = shadowLocalPosition;
shadowTransform.localScale *= 0.7f;
shadowTransform.gameObject.SetActive(false);
this.startPosition = startPosition;
this.endPosition = endPosition;
this.delay = delay;
this.endCallback = endCallback;
JumpToEnd();
}
public IEnumerator StartNewRound_LettersInWord()
{
IQuestionPack newQuestionPack = ThrowBallsConfiguration.Instance.Questions.GetNextQuestion();
currentLettersForLettersInWord = newQuestionPack.GetCorrectAnswers().ToList();
numLettersRemaining = currentLettersForLettersInWord.Count;
ResetScene();
List <int> sortedIndices = SortLettersByZIndex(currentLettersForLettersInWord.Count);
if (!uiInitialised && !IsTutorialRound())
{
uiInitialised = true;
game.Context.GetOverlayWidget().Initialize(true, false, true);
game.Context.GetOverlayWidget().SetStarsThresholds(1, 3, 5);
game.Context.GetOverlayWidget().SetMaxLives(MAX_NUM_BALLS);
}
question = newQuestionPack.GetQuestion();
SayQuestion();
yield return(new WaitForSeconds(1f));
UIController.instance.Enable();
UIController.instance.EnableLetterHint();
UIController.instance.SetLivingLetterData(question);
var letterToFlash = (LL_LetterData)currentLettersForLettersInWord[0];
var letterDataToFlash = ArabicAlphabetHelper.FindLetter(AppManager.I.DB, ((LL_WordData)question).Data, letterToFlash.Data, false)[0];
flashingTextCoroutine = ArabicTextUtilities.GetWordWithFlashingText(((LL_WordData)question).Data, letterDataToFlash.fromCharacterIndex, letterDataToFlash.toCharacterIndex, Color.green, FLASHING_TEXT_CYCLE_DURATION, int.MaxValue,
(string text) => {
UIController.instance.SetText(text);
}, false);
flashedLettersInLiWVariation.Add(letterToFlash);
ThrowBallsGame.instance.StartCoroutine(flashingTextCoroutine);
for (int i = 0; i < currentLettersForLettersInWord.Count; i++)
{
int letterObjectIndex = game.Difficulty <= ThrowBallsGame.ThrowBallsDifficulty.Easy ? sortedIndices[i] : i;
GameObject letterObj = letterPool[letterObjectIndex];
letterObj.SetActive(true);
ConfigureLetterPropAndMotionVariation(letterControllers[letterObjectIndex]);
letterControllers[letterObjectIndex].SetLetter(currentLettersForLettersInWord[i]);
letterObj.tag = currentLettersForLettersInWord[i].Id == currentLettersForLettersInWord[0].Id ? Constants.CORRECT_LETTER_TAG : Constants.WRONG_LETTER_TAG;
if (i == 0)
{
tutorialTarget = letterObj;
}
}
isRoundOngoing = true;
BallController.instance.Enable();
if (IsTutorialRound())
{
switch (ThrowBallsConfiguration.Instance.Variation)
{
case ThrowBallsVariation.LetterName:
audioManager.PlayDialogue(Database.LocalizationDataId.ThrowBalls_lettername_Tuto);
break;
case ThrowBallsVariation.LetterAny:
audioManager.PlayDialogue(Database.LocalizationDataId.ThrowBalls_lettername_Tuto);
break;
case ThrowBallsVariation.Word:
audioManager.PlayDialogue(Database.LocalizationDataId.ThrowBalls_word_Tuto);
break;
case ThrowBallsVariation.BuildWord:
audioManager.PlayDialogue(Database.LocalizationDataId.ThrowBalls_buildword_Tuto);
break;
default:
throw new ArgumentOutOfRangeException();
}
inputManager.Enabled = true;
isVoiceOverDone = true;
ShowTutorialUI();
}
}
public void SetLetter(ILivingLetterData _data)
{
letterData = _data;
letterObjectView.Init(letterData);
}
public void Init(ILivingLetterData _data)
{
letterData = _data;
displayedText.SetLetterData(letterData);
}
public void Init(ILivingLetterData _data)
{
letterData = _data;
displayedText.text = letterData.TextForLivingLetter;//ArabicAlphabetHelper.GetLetterFromUnicode(letterData.Data.Isolated_Unicode);
}
public void SetLivingLetterData(ILivingLetterData _data)
{
livingLetterData = _data;
wordFlexibleContainer.SetLetterData(_data);
}
public void SetInPhrase(ILivingLetterData _phraseId)
{
m_sInPhrase = _phraseId;
}
private GameObject QuestionView(ILivingLetterData data)
{
return(LivingLetterFactory.Instance.SpawnQuestion(data).gameObject);
}
public void Init(ILivingLetterData _letterData)
{
Reset();
letterData = _letterData;
LetterText.text = letterData.TextForLivingLetter; //ArabicAlphabetHelper.GetLetterFromUnicode(letterData.Data.Isolated_Unicode);
}
public IQuestion GetNextQuestion()
{
if (state != QuestionGeneratorState.Initialized)
{
throw new InvalidOperationException("Not Initialized");
}
state = QuestionGeneratorState.QuestionFeeded;
currentPack = provider.GetNextQuestion();
List <Answer> answers = new List <Answer>();
ILivingLetterData questionData = currentPack.GetQuestion();
LivingLetterDataType cacheLivingLetterType = LivingLetterDataType.Letter;
//____________________________________
//Prepare answers for next method call
//____________________________________
if (missingLetter)
{
// ### MISSING LETTER ###
foreach (var wrong in currentPack.GetWrongAnswers())
{
cacheLivingLetterType = wrong.DataType;
var wrongAnsw = GenerateWrongAnswer(wrong);
answers.Add(wrongAnsw);
totalAnswers.Add(wrongAnsw);
}
var correct = currentPack.GetCorrectAnswers().ToList()[0];
cacheLivingLetterType = correct.DataType;
var correctAnsw = GenerateCorrectAnswer(correct);
answers.Add(correctAnsw);
totalAnswers.Add(correctAnsw);
partialAnswers = answers.ToArray();
// Generate the question
var question = GenerateMissingLetterQuestion(questionData, correct);
totalQuestions.Add(question);
GeneratePlaceHolder(question, cacheLivingLetterType);
return(question);
}
else
{
// ### ORDER LETTERS ###
foreach (var correct in currentPack.GetCorrectAnswers())
{
var correctAnsw = GenerateCorrectAnswer(correct);
answers.Add(correctAnsw);
totalAnswers.Add(correctAnsw);
}
partialAnswers = answers.ToArray();
// Generate the question
var question = GenerateQuestion(questionData);
totalQuestions.Add(question);
return(question);
}
}
public void SetText(ILivingLetterData data)
{
Label.gameObject.SetActive(true);
NumbersLabel.gameObject.SetActive(false);
Label.SetLetterData(data);
}
public void SetQuestion(ILivingLetterData questionData)
{
this.questionData.Clear();
this.questionData.Add(questionData);
}
