642 lines
19 KiB
C#
642 lines
19 KiB
C#
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 : AbstractFeedback
|
|
{
|
|
/// <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>
|
|
/// Indicates if the game is still going
|
|
/// </summary>
|
|
private bool gameEnded;
|
|
|
|
/// <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>
|
|
/// Reference to the current user
|
|
/// </summary>
|
|
private User user;
|
|
|
|
/// <summary>
|
|
/// Reference to the minigame ScriptableObject
|
|
/// </summary>
|
|
public Minigame minigame;
|
|
|
|
/// <summary>
|
|
/// We keep the minigamelist as well so that the minigame-index doesn't get reset
|
|
/// DO NOT REMOVE
|
|
/// </summary>
|
|
public MinigameList minigamelist;
|
|
|
|
/// <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 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>
|
|
/// Reference used to set the webcam for the SignPredictor
|
|
/// </summary>
|
|
public RawImage webcamScreen;
|
|
|
|
/// <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>
|
|
/// Start is called before the first frame update
|
|
/// </summary>
|
|
public void Start()
|
|
{
|
|
signPredictor.SetModel(ModelIndex.FINGERSPELLING);
|
|
signPredictor.SwapScreen(webcamScreen);
|
|
AddSelfAsListener();
|
|
|
|
StartController();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is called at the start of the scene AND when the game is replayed
|
|
/// </summary>
|
|
public void StartController()
|
|
{
|
|
correctLetters = 0;
|
|
incorrectLetters = 0;
|
|
|
|
words.Clear();
|
|
// We use -1 instead of 0 so SetNextWord can simply increment it each time
|
|
spelledWords = -1;
|
|
wordIndex = 0;
|
|
|
|
gameEnded = false;
|
|
timerValue = 30.0f;
|
|
bonusActiveRemaining = 0.0f;
|
|
startTime = DateTime.Now;
|
|
|
|
gameEndedPanel.SetActive(false);
|
|
bonusTimeText.SetActive(false);
|
|
|
|
// Create entry in current user for keeping track of progress
|
|
user = UserList.GetCurrentUser();
|
|
var progress = user.GetMinigameProgress(minigame.index);
|
|
if (progress == null)
|
|
{
|
|
progress = new PersistentDataController.SavedMinigameProgress();
|
|
progress.minigameIndex = MinigameIndex.SPELLING_BEE;
|
|
user.AddMinigameProgress(progress);
|
|
}
|
|
UserList.Save();
|
|
|
|
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>
|
|
/// Update is called once per frame
|
|
/// </summary>
|
|
public void Update()
|
|
{
|
|
if (!gameEnded)
|
|
{
|
|
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();
|
|
}
|
|
|
|
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 int CalculateScore()
|
|
{
|
|
return correctLetters * correctLettersScore + incorrectLetters * incorrectLettersScore;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays the game over panel and score values
|
|
/// </summary>
|
|
public void ActivateGameOver()
|
|
{
|
|
gameEnded = true;
|
|
DeleteWord();
|
|
|
|
// Save the scores and show the scoreboard
|
|
SaveScores();
|
|
gameEndedPanel.GetComponent<GameEndedPanel>().GenerateContent(
|
|
startTime: startTime,
|
|
totalWords: spelledWords,
|
|
correctLetters: correctLetters,
|
|
incorrectLetters: incorrectLetters,
|
|
result: "VERLOREN",
|
|
score: CalculateScore()
|
|
);
|
|
|
|
gameEndedPanel.SetActive(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display win screen
|
|
/// </summary>
|
|
public void ActivateWin()
|
|
{
|
|
gameEnded = true;
|
|
DeleteWord();
|
|
|
|
// Save the scores and show the scoreboard
|
|
SaveScores();
|
|
gameEndedPanel.GetComponent<GameEndedPanel>().GenerateContent(
|
|
startTime: startTime,
|
|
totalWords: spelledWords,
|
|
correctLetters: correctLetters,
|
|
incorrectLetters: incorrectLetters,
|
|
result: "GEWONNEN",
|
|
score: CalculateScore()
|
|
);
|
|
|
|
gameEndedPanel.SetActive(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update and save the scores
|
|
/// </summary>
|
|
public void SaveScores()
|
|
{
|
|
// Calculate new score
|
|
int newScore = CalculateScore();
|
|
|
|
// Save the score as a tuple: < int score, string time ago>
|
|
Score score = new Score();
|
|
score.scoreValue = newScore;
|
|
score.time = DateTime.Now.ToString();
|
|
|
|
// Save the new score
|
|
var progress = user.GetMinigameProgress(minigame.index);
|
|
|
|
// Get the current list of scores
|
|
List<Score> latestScores = progress.latestScores;
|
|
List<Score> highestScores = progress.highestScores;
|
|
|
|
// Add the new score
|
|
latestScores.Add(score);
|
|
highestScores.Add(score);
|
|
|
|
// Sort the scores
|
|
highestScores.Sort((a, b) => b.scoreValue.CompareTo(a.scoreValue));
|
|
|
|
// Only save the top 10 scores, so this list doesn't keep growing endlessly
|
|
progress.latestScores = latestScores.Take(10).ToList();
|
|
progress.highestScores = highestScores.Take(10).ToList();
|
|
|
|
UserList.Save();
|
|
}
|
|
|
|
/// <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 (gameEnded) { 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();
|
|
}
|
|
}
|
|
|
|
/// <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))
|
|
{
|
|
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);
|
|
}
|
|
}
|