Sprint 4

Assets/SpellingBee/Scripts/SpellingBeeController.cs

@@ -0,0 +1,637 @@
+using DigitalRuby.Tween;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public partial class SpellingBeeController : AbstractMinigameController
+{
+    /// <summary>
+    /// All of the words that can be used in this session
+    /// </summary>
+    //private string[] words;
+    private List<Learnable> words = new List<Learnable>();
+
+    /// <summary>
+    /// Where we currently are in the word
+    /// </summary>
+    private int letterIndex;
+
+    /// <summary>
+    /// Where we currently are in the word list
+    /// </summary>
+    private int wordIndex;
+
+    /// <summary>
+    /// The word that is currently being spelled
+    /// </summary>
+    private string currentWord;
+
+    /// <summary>
+    /// All of the available themes
+    /// </summary>
+    public ThemeList themeList;
+
+    /// <summary>
+    /// The theme we are currently using
+    /// </summary>
+    private Theme currentTheme;
+
+    /// <summary>
+    /// Current value of timer in seconds
+    /// </summary>
+    private float timerValue;
+
+    /// <summary>
+    /// List of learnables to get the threshold for the letters
+    /// </summary>
+    public Theme fingerspelling;
+
+    /// <summary>
+    /// Amount of seconds user gets per letter of the current word
+    /// Set to 1 for testing; should be increased later
+    /// </summary>
+    private const int secondsPerLetter = 5;
+
+    /// <summary>
+    /// Counter that keeps track of how many letters have been spelled correctly
+    /// </summary>
+    private int correctLetters;
+
+    /// <summary>
+    /// Counter that keeps track of how many letters have been spelled incorrectly
+    /// </summary>
+    private int incorrectLetters;
+
+    /// <summary>
+    /// Counter that keeps track of how many words have been spelled correctly
+    /// </summary>
+    private int spelledWords;
+
+    /// <summary>
+    /// Timer that keeps track of when the game was started
+    /// </summary>
+    private DateTime startTime;
+
+    /// <summary>
+    /// Letter prefab
+    /// </summary>
+    public GameObject letterPrefab;
+
+    /// <summary>
+    /// Reference to letter container
+    /// </summary>
+    public Transform letterContainer;
+
+    /// <summary>
+    /// The Image component for displaying the appropriate sprite
+    /// </summary>
+    public Image wordImage;
+
+    /// <summary>
+    /// Timer display
+    /// </summary>
+    public TMP_Text timerText;
+
+    /// <summary>
+    /// Bonus time display
+    /// </summary>
+    public GameObject bonusTimeText;
+
+    /// <summary>
+    /// Timer to display the bonus time
+    /// </summary>
+    private float bonusActiveRemaining = 0.0f;
+
+    /// <summary>
+    /// The GameObjects representing the letters
+    /// </summary>
+    private List<GameObject> letters = new List<GameObject>();
+
+    /// <summary>
+    /// Reference to the scoreboard
+    /// </summary>
+    public Transform Scoreboard;
+
+    /// <summary>
+    /// Reference to the feedback field
+    /// </summary>
+    public TMP_Text feedbackText;
+
+    /// <summary>
+    /// Reference to the progress bar image, so we can add fancy colors
+    /// </summary>
+    public Image feedbackProgressImage;
+
+    /// <summary>
+    /// Timer to keep track of how long a incorrect sign is performed
+    /// </summary>
+    protected DateTime timer;
+
+    /// <summary>
+    /// Current predicted sign
+    /// </summary>
+    protected string predictedSign = null;
+
+    /// <summary>
+    /// Previous incorrect sign, so we can keep track whether the user is wrong or the user is still changing signs
+    /// </summary>
+    protected string previousIncorrectSign = null;
+
+    /// <summary>
+    /// Reference to display the score
+    /// </summary>
+    public TMP_Text scoreDisplay;
+
+    /// <summary>
+    /// Reference to display the points lost/won
+    /// </summary>
+    public TMP_Text scoreBonus;
+
+    /// <summary>
+    /// Score obtained when spelling a letter
+    /// </summary>
+    private int correctLettersScore = 10;
+
+    /// <summary>
+    /// Score obtained when spelling the wrong letter :o
+    /// </summary>
+    private int incorrectLettersScore = -5;
+
+    /// <summary>
+    /// Set the AbstractMinigameController variable to inform it of the theme for the signPredictor
+    /// </summary>
+    protected override Theme signPredictorTheme
+    {
+        get { return fingerspelling; }
+    }
+
+    /// <summary>
+    /// Update is called once per frame
+    /// </summary>
+    public void Update()
+    {
+        if (gameIsActive)
+        {
+            timerValue -= Time.deltaTime;
+            if (bonusActiveRemaining <= 0.0 && bonusTimeText.activeSelf)
+            {
+                bonusTimeText.SetActive(false);
+                scoreBonus.text = "";
+            }
+            else
+            {
+                bonusActiveRemaining -= Time.deltaTime;
+            }
+
+            if (timerValue <= 0.0f)
+            {
+                timerValue = 0.0f;
+                //ActivateGameOver();
+                ActivateEnd(false);
+            }
+
+            int minutes = Mathf.FloorToInt(timerValue / 60.0f);
+            int seconds = Mathf.FloorToInt(timerValue % 60.0f);
+
+            timerText.text = string.Format("{0:00}:{1:00}", minutes, seconds);
+
+        }
+    }
+
+    /// <summary>
+    /// Randomly shuffle the list of words
+    /// </summary>
+    public void ShuffleWords()
+    {
+        for (int i = words.Count - 1; i > 0; i--)
+        {
+            // Generate a random index between 0 and i (inclusive)
+            int j = UnityEngine.Random.Range(0, i + 1);
+
+            // Swap the values at indices i and j
+            (words[j], words[i]) = (words[i], words[j]);
+        }
+    }
+
+    /// <summary>
+    /// Calculate the score
+    /// </summary>
+    /// <returns>The calculated score</returns>
+    public override int CalculateScore()
+    {
+        return correctLetters * correctLettersScore + incorrectLetters * incorrectLettersScore;
+    }
+
+    /// <summary>
+    /// Delete all letter objects
+    /// </summary>
+    public void DeleteWord()
+    {
+        for (int i = 0; i < letters.Count; i++)
+        {
+            Destroy(letters[i]);
+        }
+        letters.Clear();
+    }
+
+    /// <summary>
+    /// Adds seconds to timer
+    /// </summary>
+    /// <param name="seconds"></param>
+    public void AddSeconds(int seconds)
+    {
+        timerValue += (float)seconds;
+        bonusTimeText.SetActive(true);
+        bonusActiveRemaining = 1.0f;
+    }
+
+    /// <summary>
+    /// Display the next letter
+    /// </summary>
+    /// <param name="successful">true if the letter was correctly signed, false otherwise</param>
+    public void NextLetter(bool successful)
+    {
+        if (!gameIsActive) { return; }
+
+        // Change color of current letter (skip spaces)
+        if (successful)
+        {
+            correctLetters++;
+            letters[letterIndex].GetComponent<Image>().color = new Color(0x8b / 255.0f, 0xd4 / 255.0f, 0x5e / 255.0f);
+            scoreDisplay.text = $"Score: {CalculateScore()}";
+            scoreBonus.text = $"+{correctLettersScore}";
+            scoreBonus.color = new Color(0x8b / 255.0f, 0xd4 / 255.0f, 0x5e / 255.0f);
+        }
+        else
+        {
+            incorrectLetters++;
+            letters[letterIndex].GetComponent<Image>().color = new Color(0xf5 / 255.0f, 0x49 / 255.0f, 0x3d / 255.0f);
+            scoreDisplay.text = $"Score: {CalculateScore()}";
+            scoreBonus.text = $"{incorrectLettersScore}";
+            scoreBonus.color = new Color(0xf5 / 255.0f, 0x49 / 255.0f, 0x3d / 255.0f);
+        }
+
+        do
+        {
+            letterIndex++;
+        } while (letterIndex < currentWord.Length && currentWord[letterIndex] == ' ');
+
+        // Change the color of the next letter or change to new word
+        if (letterIndex < currentWord.Length)
+        {
+            letters[letterIndex].GetComponent<Image>().color = new Color(0x9f / 255.0f, 0xe7 / 255.0f, 0xf5 / 255.0f);
+        }
+        else
+        {
+            StartCoroutine(Wait());
+            NextWord();
+        }
+    }
+
+    /// <summary>
+    /// Display next word in the series
+    /// </summary>
+    public void NextWord()
+    {
+        DeleteWord();
+        spelledWords++;
+
+        if (wordIndex < words.Count)
+        {
+            currentWord = words[wordIndex].name;
+            letterIndex = 0;
+
+            DisplayWord(currentWord);
+            wordIndex++;
+        }
+        else
+        {
+            //ActivateWin();
+            ActivateEnd(true);
+        }
+    }
+
+    /// <summary>
+    /// Displays the word that needs to be spelled
+    /// </summary>
+    /// <param name="word">The word to display</param>
+    public void DisplayWord(string word)
+    {
+        for (int i = 0; i < word.Length; i++)
+        {
+            // Create instance of prefab
+            GameObject instance = GameObject.Instantiate(letterPrefab, letterContainer);
+            letters.Add(instance);
+
+            // Dynamically load appearance
+            char c = Char.ToUpper(word[i]);
+            Image background = instance.GetComponent<Image>();
+            background.color = i == 0 ? new Color(0x9f / 255.0f, 0xe7 / 255.0f, 0xf5 / 255.0f) : Color.clear;
+            TMP_Text txt = instance.GetComponentInChildren<TMP_Text>();
+            txt.text = Char.ToString(c);
+        }
+        wordImage.sprite = words[wordIndex].image;
+    }
+
+    /// <summary>
+    /// wait for 2 seconds
+    /// </summary>
+    /// <returns></returns>
+    private IEnumerator Wait()
+    {
+        yield return new WaitForSecondsRealtime(2);
+    }
+
+    /// <summary>
+    /// Get the threshold for a given sign
+    /// </summary>
+    /// <param name="sign"></param>
+    /// <returns></returns>
+    private float GetTresholdPercentage(string sign)
+    {
+        Learnable letter = fingerspelling.learnables.Find(l => l.name == sign);
+        return letter.thresholdPercentage;
+    }
+    /*
+    /// <summary>
+    /// The updateFunction that is called when new probabilities become available
+    /// </summary>
+    /// <returns></returns>
+    protected override IEnumerator UpdateFeedback()
+    {
+        // Get current sign
+        string currentSign = GetSign();
+        // Get the predicted sign
+        if (signPredictor != null && signPredictor.learnableProbabilities != null &&
+            currentSign != null && signPredictor.learnableProbabilities.ContainsKey(currentSign) && gameIsActive)
+        {
+            float accCurrentSign = signPredictor.learnableProbabilities[currentSign];
+            float thresholdCurrentSign = GetTresholdPercentage(currentSign);
+
+            // Get highest predicted sign
+            string predictedSign = signPredictor.learnableProbabilities.Aggregate((a, b) => a.Value > b.Value ? a : b).Key;
+            float accPredictSign = signPredictor.learnableProbabilities[predictedSign];
+            float thresholdPredictedSign = GetTresholdPercentage(predictedSign);
+
+            if (feedbackText != null && feedbackProgressImage != null)
+            {
+                Color col;
+                if (accCurrentSign > thresholdCurrentSign)
+                {
+                    feedbackText.text = "Goed";
+                    col = new Color(0x8b / 255.0f, 0xd4 / 255.0f, 0x5e / 255.0f);
+                }
+                else if (accCurrentSign > 0.9 * thresholdCurrentSign)
+                {
+                    feedbackText.text = "Bijna...";
+                    col = new Color(0xf2 / 255.0f, 0x7f / 255.0f, 0x0c / 255.0f);
+                }
+                else if (accPredictSign > thresholdPredictedSign)
+                {
+                    feedbackText.text = $"Verkeerde gebaar: '{predictedSign}'";
+                    col = new Color(0xf5 / 255.0f, 0x49 / 255.0f, 0x3d / 255.0f);
+                    accCurrentSign = 0.0f;
+                }
+                else
+                {
+                    feedbackText.text = "Detecteren...";
+                    col = new Color(0xf5 / 255.0f, 0x49 / 255.0f, 0x3d / 255.0f);
+                }
+
+                feedbackText.color = col;
+                feedbackProgressImage.color = col;
+
+                float oldValue = feedbackProgress.value;
+                // use an exponential scale 
+                float newValue = Mathf.Exp(4 * (Mathf.Clamp(accCurrentSign / thresholdCurrentSign, 0.0f, 1.0f) - 1.0f));
+                feedbackProgress.gameObject.Tween("FeedbackUpdate", oldValue, newValue, 0.2f, TweenScaleFunctions.CubicEaseInOut, (t) =>
+                {
+                    if (feedbackProgress != null)
+                    {
+                        feedbackProgress.value = t.CurrentValue;
+                    }
+                });
+            }
+
+
+            if (accPredictSign > thresholdPredictedSign)
+            {
+                // Correct sign
+                if (predictedSign == currentSign)
+                {
+                    yield return new WaitForSeconds(0.5f);
+                    PredictSign(predictedSign);
+                    timer = DateTime.Now;
+                    predictedSign = null;
+                    previousIncorrectSign = null;
+                }
+                // Incorrect sign
+                else
+                {
+                    if (previousIncorrectSign != predictedSign)
+                    {
+                        timer = DateTime.Now;
+                        previousIncorrectSign = predictedSign;
+                    }
+                    else if (DateTime.Now - timer > TimeSpan.FromSeconds(2.0f))
+                    {
+                        PredictSign(predictedSign);
+                        timer = DateTime.Now;
+                        predictedSign = null;
+                        previousIncorrectSign = null;
+                    }
+                }
+
+            }
+        }
+        else if (feedbackProgress != null)
+        {
+
+            feedbackProgress.value = 0.0f;
+        }
+        yield return null;
+    }
+    */
+    /// <summary>
+    /// Function to get the current letter that needs to be signed
+    /// </summary>
+    /// <returns>the current letter that needs to be signed</returns>
+    public string GetSign()
+    {
+        if (letterIndex < currentWord.Length)
+        {
+            return currentWord[letterIndex].ToString().ToUpper();
+        }
+        return null;
+    }
+    /// <summary>
+    /// Function to confirm your prediction and check if it is correct. 
+    /// </summary>
+    /// <param name="sign"></param>
+    public void PredictSign(string sign)
+    {
+        bool successful = sign.ToUpper() == currentWord[letterIndex].ToString().ToUpper();
+        if (successful)
+        {
+            AddSeconds(secondsPerLetter);
+        }
+        NextLetter(successful);
+    }
+
+    /// <summary>
+    /// The logic to process the signs sent by the signPredictor
+    /// </summary>
+    /// <param name="accuracy">The accuracy of the passed sign</param>
+    /// <param name="predictedSign">The name of the passed sign</param>
+    protected override void ProcessMostProbableSign(float accuracy, string predictedSign)
+    {
+        string currentSign = GetSign();
+        float accPredictSign = accuracy;
+        float accCurrentSign = signPredictor.learnableProbabilities[currentSign];
+        float thresholdCurrentSign = GetTresholdPercentage(currentSign);
+        float thresholdPredictedSign = GetTresholdPercentage(predictedSign);
+
+        // If there is a feedback-object, we wil change its appearance
+        if (feedbackText != null && feedbackProgressImage != null)
+        {
+            Color col;
+            if (accPredictSign > thresholdCurrentSign)
+            {
+                feedbackText.text = "Goed";
+                col = new Color(0x8b / 255.0f, 0xd4 / 255.0f, 0x5e / 255.0f);
+            }
+            else if (accCurrentSign > 0.9 * thresholdCurrentSign)
+            {
+                feedbackText.text = "Bijna...";
+                col = new Color(0xf2 / 255.0f, 0x7f / 255.0f, 0x0c / 255.0f);
+            }
+            else if (accPredictSign > thresholdPredictedSign)
+            {
+                feedbackText.text = $"Verkeerde gebaar: '{predictedSign}'";
+                col = new Color(0xf5 / 255.0f, 0x49 / 255.0f, 0x3d / 255.0f);
+                accCurrentSign = 0.0f;
+            }
+            else
+            {
+                feedbackText.text = "Detecteren...";
+                col = new Color(0xf5 / 255.0f, 0x49 / 255.0f, 0x3d / 255.0f);
+            }
+
+            feedbackText.color = col;
+            feedbackProgressImage.color = col;
+
+            float oldValue = feedbackProgress.value;
+            // use an exponential scale 
+            float newValue = Mathf.Exp(4 * (Mathf.Clamp(accCurrentSign / thresholdCurrentSign, 0.0f, 1.0f) - 1.0f));
+            feedbackProgress.gameObject.Tween("FeedbackUpdate", oldValue, newValue, 0.2f, TweenScaleFunctions.CubicEaseInOut, (t) =>
+            {
+                if (feedbackProgress != null)
+                {
+                    feedbackProgress.value = t.CurrentValue;
+                }
+            });
+        }
+
+        // The logic for the internal workings of the game
+        if (accPredictSign > thresholdPredictedSign)
+        {
+            // Correct sign, instantly pass it along
+            if (predictedSign == currentSign)
+            {
+                PredictSign(predictedSign);
+                timer = DateTime.Now;
+                predictedSign = null;
+                previousIncorrectSign = null;
+            }
+
+            // Incorrect sign, wait a bit before passing it along
+            else
+            {
+                if (previousIncorrectSign != predictedSign)
+                {
+                    timer = DateTime.Now;
+                    previousIncorrectSign = predictedSign;
+                }
+                else if (DateTime.Now - timer > TimeSpan.FromSeconds(2.0f))
+                {
+                    PredictSign(predictedSign);
+                    timer = DateTime.Now;
+                    predictedSign = null;
+                    previousIncorrectSign = null;
+                }
+            }
+
+        }
+    }
+
+    /// <summary>
+    /// The logic to set the scoreboard of spellingbee
+    /// </summary>
+    /// <param name="victory">SHows whether or not the player won</param>
+    protected override void SetScoreBoard(bool victory)
+    {
+        string resultTxt;
+        if (victory)
+        {
+            resultTxt = "GEWONNEN";
+        }
+        else
+        {
+            resultTxt = "VERLOREN";
+        }
+        // Save the scores and show the scoreboard
+        gameEndedPanel.GetComponent<SpellingBeeGameEndedPanel>().GenerateContent(
+            startTime: startTime,
+            totalWords: spelledWords,
+            correctLetters: correctLetters,
+            incorrectLetters: incorrectLetters,
+            result: resultTxt,
+            score: CalculateScore()
+        );
+    }
+
+    /// <summary>
+    /// The spellinbee-specific logic that needs to be called at the start of the game
+    /// </summary>
+    protected override void StartGameLogic()
+    {
+        correctLetters = 0;
+        incorrectLetters = 0;
+
+        words.Clear();
+        // We use -1 instead of 0 so SetNextWord can simply increment it each time
+        spelledWords = -1;
+        wordIndex = 0;
+
+        gameIsActive = true;
+        timerValue = 30.0f;
+        bonusActiveRemaining = 0.0f;
+        startTime = DateTime.Now;
+
+        gameEndedPanel.SetActive(false);
+        bonusTimeText.SetActive(false);
+
+        currentTheme = minigame.themeList.themes[minigame.themeList.currentThemeIndex];
+        //feedback.signPredictor.SetModel(currentTheme.modelIndex);
+        words.AddRange(currentTheme.learnables);
+        ShuffleWords();
+        NextWord();
+
+        scoreDisplay.text = $"Score: {CalculateScore()}";
+        scoreBonus.text = "";
+    }
+
+    /// <summary>
+    /// The spellingbee-specific logic that needs to be called at the end of a game
+    /// </summary>
+    /// <param name="victory"></param>
+    protected override void EndGameLogic(bool victory)
+    {
+        gameIsActive = false;
+        DeleteWord();
+    }
+}