Resolve WES-131-Feedback-REfactor

Assets/SpellingBee/Scripts/SpellingBeeController.cs

@@ -5,8 +5,9 @@ using System.Linq;
 using TMPro;
 using UnityEngine;
 using UnityEngine.UI;
+using DigitalRuby.Tween;
 
-public partial class SpellingBeeController : MonoBehaviour
+public partial class SpellingBeeController : AbstractFeedback
 {
     /// <summary>
     /// All of the words that can be used in this session
@@ -136,20 +137,55 @@ public partial class SpellingBeeController : MonoBehaviour
     /// </summary>
     public Transform Scoreboard;
 
-    /// <summary>
-    /// Accuracy feeback object
-    /// </summary>
-    public Feedback feedback;
-
     /// <summary>
     /// Reference to the gameEnded panel, so we can update its display
     /// </summary>
     public GameObject gameEndedPanel;
 
+    /// <summary>
+    /// Reference to the feedback field
+    /// </summary>
+    public TMP_Text feedbackText;
+
+    /// <summary>
+    /// Reference to the progress bar
+    /// </summary>
+    public Slider feedbackProgress;
+
+    /// <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>
     /// Start is called before the first frame update
     /// </summary>
     public void Start()
+    {
+        StartController();
+
+        signPredictor.SetModel(currentTheme.modelIndex);
+        AddSelfAsListener();
+    }
+    /// <summary>
+    /// Is called at the start of the scene AND when the game is replayed
+    /// </summary>
+    public void StartController()
     {
         correctLetters = 0;
         incorrectLetters = 0;
@@ -182,29 +218,10 @@ public partial class SpellingBeeController : MonoBehaviour
         userList.Save();
 
         currentTheme = minigame.themeList.themes[minigame.themeList.currentThemeIndex];
-        feedback.signPredictor.ChangeModel(currentTheme.modelIndex);
+        //feedback.signPredictor.ChangeModel(currentTheme.modelIndex);
         words.AddRange(currentTheme.learnables);
         ShuffleWords();
         NextWord();
-
-        // Set calllbacks
-        feedback.getSignCallback = () =>
-        {
-            if (letterIndex < currentWord.Length)
-            {
-                return currentWord[letterIndex].ToString().ToUpper();
-            }
-            return null;
-        };
-        feedback.predictSignCallback = (sign) =>
-        {
-            bool successful = sign.ToUpper() == currentWord[letterIndex].ToString().ToUpper();
-            if (successful)
-            {
-                AddSeconds(secondsPerLetter);
-            }
-            NextLetter(successful);
-        };
     }
 
     /// <summary>
@@ -453,4 +470,116 @@ public partial class SpellingBeeController : MonoBehaviour
     {
         yield return new WaitForSecondsRealtime(2);
     }
+
+    /// <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))
+        {
+            float accuracy = signPredictor.learnableProbabilities[currentSign];
+            if (feedbackText != null && feedbackProgressImage != null)
+            {
+                if (accuracy > 0.90)
+                {
+                    feedbackText.text = "Goed";
+                    feedbackText.color = Color.green;
+                    feedbackProgressImage.color = Color.green;
+                }
+                else if (accuracy > 0.80)
+                {
+                    feedbackText.text = "Bijna...";
+                    Color col = new Color(0xff / 255.0f, 0x66 / 255.0f, 0x00 / 255.0f);
+                    feedbackText.color = col;
+                    feedbackProgressImage.color = col;
+                }
+                else
+                {
+                    feedbackText.text = "Detecteren...";
+                    feedbackText.color = Color.red;
+                    feedbackProgressImage.color = Color.red;
+                }
+
+                float oldValue = feedbackProgress.value;
+                // use an exponential scale 
+                float newValue = Mathf.Exp(4 * (accuracy - 1.0f));
+                feedbackProgress.gameObject.Tween("FeedbackUpdate", oldValue, newValue, 0.2f, TweenScaleFunctions.CubicEaseInOut, (t) =>
+                {
+                    if (feedbackProgress != null)
+                    {
+                        feedbackProgress.value = t.CurrentValue;
+                    }
+                });
+            }
+
+            // Check whether (in)correct sign has high accuracy
+            foreach (var kv in signPredictor.learnableProbabilities)
+            {
+                if (kv.Value > 0.90)
+                {
+                    predictedSign = kv.Key;
+                    // Correct sign
+                    if (predictedSign == currentSign)
+                    {
+                        yield return new WaitForSeconds(1.0f);
+                        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;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        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);
+    }
 }