WeSign/unity-application
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 6 Wiki Activity

Sprint 4

Browse Source
This commit is contained in:
Jelle De Geest
2023-04-26 19:04:34 +02:00
parent 172938cec8
commit 47f8b96122
1004 changed files with 60756 additions and 117444 deletions
Download Patch File Download Diff File Expand all files Collapse all files

612
Assets/JustSign/Scripts/JustSignController.cs
View File

@@ -1,26 +1,21 @@
using System;
using DigitalRuby.Tween;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using Random = UnityEngine.Random;
/// <summary>
/// Contains all game logic for the JustSign game
/// </summary>
public class JustSignController : MonoBehaviour
{
public class JustSignController : AbstractMinigameController
{
/// <summary>
/// All of the words that can be used in this session
/// </summary>
private List<Learnable> words = new List<Learnable>();
/// <summary>
/// The canvas containing all components
/// </summary>
public Canvas canvas;
/// <summary>
/// The input field where the user can type his or her answer
/// </summary>
@@ -29,24 +24,13 @@ public class JustSignController : MonoBehaviour
/// <summary>
/// The feedback on the timing
/// </summary>
public TMP_Text feedBack;
public TMP_Text timingFeedback;
/// <summary>
/// The current score
/// </summary>
public TMP_Text scoreDisplay;
/// <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>
/// Reference to the list of available songs
/// </summary>
@@ -57,11 +41,45 @@ public class JustSignController : MonoBehaviour
/// </summary>
private Song currentSong;
/// <summary>
/// Reference to the perfect hitzone
/// </summary>
public RectTransform hitZonePerfect;
/// <summary>
/// The zone that the player should be hitting with his or her inputs
/// Reference to the good hitzone
/// </summary>
public GameObject hitZone;
public RectTransform hitZoneGood;
/// <summary>
/// Reference to the meh hitzone
/// </summary>
public RectTransform hitZoneMeh;
/// <summary>
/// Score obtained when getting a perfect hit
/// </summary>
private int perfectScore = 50;
/// <summary>
/// Score obtained when getting a good hit
/// </summary>
private int goodScore = 20;
/// <summary>
/// Score obtained when getting a meh hit
/// </summary>
private int mehScore = 10;
/// <summary>
/// Score obtained when getting a terrible hit
/// </summary>
private int terribleScore = -3;
/// <summary>
/// Score obtained when symbol goes offscreen
/// </summary>
private int offscreenScore = -5;
/// <summary>
/// Symbol prefab
@@ -88,75 +106,20 @@ public class JustSignController : MonoBehaviour
/// </summary>
private List<GameObject> activeSymbols = new List<GameObject>();
/// <summary>
/// The current score
/// </summary>
private int score;
/// <summary>
/// Have the symbols started spawning or not
/// </summary>
private bool gameIsActive = false;
/// <summary>
/// Width and height of the symbols
/// </summary>
private int symbolSize = 280;
/// <summary>
/// Controls movement speed of symbols (higher -> faster)
/// </summary>
private int moveSpeed = 200;
private int moveSpeed = 100;
/// <summary>
/// Starting X-coordinate of a symbol = (-1920 - symbolsize) / 2
/// </summary>
private int trackX = -1100;
private int trackX = 1920 / 2;
/// <summary>
/// Starting Y-coordinate of a symbol
/// </summary>
private int trackY = -200;
/// <summary>
/// Max distance from hit zone to get perfect score
/// </summary>
private int perfectBoundary = 10;
/// <summary>
/// Score obtained when getting a perfect hit
/// </summary>
private int perfectScore = 5;
/// <summary>
/// Max distance from hit zone to get good score
/// </summary>
private int goodBoundary = 120;
/// <summary>
/// Score obtained when getting a good hit
/// </summary>
private int goodScore = 3;
/// <summary>
/// Max distance from hit zone to get meh score
/// </summary>
private int mehBoundary = 200;
/// <summary>
/// Score obtained when getting a meh hit
/// </summary>
private int mehScore = 1;
/// <summary>
/// Score obtained when getting a terrible hit
/// </summary>
private int terribleScore = -3;
/// <summary>
/// Score obtained when symbol goes offscreen
/// </summary>
private int offscreenScore = -5;
private int trackY = 0;
/// <summary>
/// Time at which the last symbol was spawned
@@ -198,31 +161,6 @@ public class JustSignController : MonoBehaviour
/// </summary>
private int incorrectSigns;
/// <summary>
/// Reference to the scoreboard entries container
/// </summary>
public Transform scoreboardEntriesContainer;
/// <summary>
/// The GameObjects representing the letters
/// </summary>
private List<GameObject> scoreboardEntries = new List<GameObject>();
/// <summary>
/// Reference to the ScoreboardEntry prefab
/// </summary>
public GameObject scoreboardEntry;
/// <summary>
/// Reference to the user list to access the current user
/// </summary>
public UserList userList;
/// <summary>
/// Reference to the current user
/// </summary>
private User user;
/// <summary>
/// LPM
/// </summary>
@@ -259,45 +197,58 @@ public class JustSignController : MonoBehaviour
public TMP_Text scoreText;
/// <summary>
/// Reference to the gameEnded panel, so we can update its display
/// Reference to the feedback field
/// </summary>
public GameObject gameEndedPanel;
public TMP_Text feedbackText;
/// <summary>
/// Start is called before the first frame update
/// Reference to the progress bar image, so we can add fancy colors
/// </summary>
public void Start()
public Image feedbackProgressImage;
/// <summary>
/// Sprite shown when perfect score
/// </summary>
public Sprite perfectSprite;
/// <summary>
/// Sprite shown when good score
/// </summary>
public Sprite goodSprite;
/// <summary>
/// Sprite shown when meh score
/// </summary>
public Sprite mehSprite;
/// <summary>
/// Sprite shown when terrible score (too soon)
/// </summary>
public Sprite terribleSprite;
/// <summary>
/// Sprite shown when sign leaves screen
/// </summary>
public Sprite tooLateSprite;
/// <summary>
/// Reference to display the feedback image
/// </summary>
public Image imageFeedback;
/// <summary>
/// Message to display when there is no model
/// </summary>
public GameObject previewMessage;
/// <summary>
/// Reference to the score, feedback and image
/// </summary>
public GameObject userFeedback;
protected override Theme signPredictorTheme
{
perfectSigns = 0;
goodSigns = 0;
mehSigns = 0;
terribleSigns = 0;
incorrectSigns = 0;
score = 0;
gameEndedPanel.SetActive(false);
// Create entry in current user for keeping track of progress
userList.Load();
user = userList.GetCurrentUser();
Progress progress = user.GetMinigameProgress(minigame.index);
if (progress == null)
{
progress = new Progress();
progress.AddOrUpdate<MinigameIndex>("minigameIndex", minigame.index);
progress.AddOrUpdate<List<Score>>("highestScores", new List<Score>());
progress.AddOrUpdate<List<Score>>("latestScores", new List<Score>());
user.minigames.Add(progress);
}
userList.Save();
scoreDisplay.text = "Score: " + score.ToString();
currentTheme = minigame.themeList.themes[minigame.themeList.currentThemeIndex];
words.AddRange(currentTheme.learnables);
currentSong = songList.songs[songList.currentSongIndex];
AudioSource.PlayClipAtPoint(currentSong.song, Vector3.zero, 1.0f);
beginTime = Time.time;
lastSymbolTime = beginTime + currentSong.duration - 1920.0f / moveSpeed;
StartCoroutine(WaitThenStart(currentSong.firstSymbolTime));
get { return currentTheme; }
}
/// <summary>
@@ -314,94 +265,62 @@ public class JustSignController : MonoBehaviour
/// Update is called once per frame
/// </summary>
void Update()
{
if (gameIsActive) {
int matchedSymbolIndex = -1;
for (int i = 0; i < activeWords.Count; i++) {
if (activeWords[i].ToLower() == answerField.text.ToLower()) {
matchedSymbolIndex = i;
}
}
// Destroy the oldest symbol if the current input matches it
if (matchedSymbolIndex >= 0) {
int difference = Math.Abs((int) (activeSymbols[matchedSymbolIndex].transform.position.x - hitZone.transform.position.x));
if (difference < perfectBoundary) {
feedBack.text = "Perfect!";
perfectSigns++;
score += perfectScore;
} else if (difference < goodBoundary) {
feedBack.text = "Good!";
goodSigns++;
score += goodScore;
} else if (difference < mehBoundary) {
feedBack.text = "Meh...";
mehSigns++;
score += mehScore;
} else {
feedBack.text = "Terrible!";
terribleSigns++;
score += terribleScore;
}
DestroySymbolAt(matchedSymbolIndex);
answerField.text = "";
}
{
if (gameIsActive)
{
// Destroy the oldest symbol if it leaves the screen
if (activeSymbols.Count > 0) {
if (activeSymbols[0].GetComponent<RectTransform>().localPosition.x > -trackX) {
if (activeSymbols.Count > 0)
{
if (activeSymbols[0].GetComponent<RectTransform>().localPosition.x > trackX)
{
DestroySymbolAt(0);
incorrectSigns++;
feedBack.text = "Te laat!";
score += offscreenScore;
timingFeedback.text = $"Te laat! \n {offscreenScore}";
imageFeedback.sprite = tooLateSprite;
}
}
// Spawn new symbol every spawn period
float currentTime = Time.time;
if (currentTime - lastSpawn > currentSong.spawnPeriod && lastSymbolTime > currentTime) {
if (currentTime - lastSpawn > currentSong.spawnPeriod && lastSymbolTime > currentTime)
{
lastSpawn = currentTime;
SpawnNewSymbol();
}
// Check if the song has ended and activate scorescreen if it has
if (currentTime - beginTime > currentSong.duration) {
ActivateEnd();
if (currentTime - beginTime > currentSong.duration)
{
// The boolean that is passed is irrelevant for this game
ActivateEnd(true);
}
// Move all active symbols to the right
foreach (GameObject symbol in activeSymbols) {
foreach (GameObject symbol in activeSymbols)
{
RectTransform rectTransform = symbol.GetComponent<RectTransform>();
rectTransform.localPosition = new Vector3(rectTransform.localPosition.x + Time.deltaTime * moveSpeed, trackY, 0);
}
scoreDisplay.text = "Score: " + score.ToString();
scoreDisplay.text = $"Score: {CalculateScore()}";
}
}
/// <summary>
/// Display Scoreboard + Metrics
/// Calculate the score
/// </summary>
public void ActivateEnd()
/// <returns>The calculated score</returns>
public override int CalculateScore()
{
gameIsActive = false;
while (activeSymbols.Count > 0)
{
DestroySymbolAt(0);
}
// TODO: Scoreboard
SaveScores();
SetScoreMetrics();
SetScoreBoard();
gameEndedPanel.SetActive(true);
return goodSigns * goodScore + perfectSigns * perfectScore + mehScore * mehSigns + terribleScore * terribleSigns + incorrectSigns * offscreenScore;
}
/// <summary>
/// Destroy the symbol at the given index
/// </summary>
/// <param name="index">The index of the symbol to destroy</param>
void DestroySymbolAt(int index) {
void DestroySymbolAt(int index)
{
activeWords.RemoveAt(index);
GameObject symbol = activeSymbols[index];
activeSymbols.RemoveAt(index);
@@ -411,198 +330,191 @@ public class JustSignController : MonoBehaviour
/// <summary>
/// Create a new symbol at the start of the track
/// </summary>
void SpawnNewSymbol() {
void SpawnNewSymbol()
{
// Pick a word that isn't in use yet
List<int> unusedWordIndices = new List<int>();
for (int i = 0; i < words.Count; i++) {
if (!activeWords.Contains(words[i].name)) {
for (int i = 0; i < words.Count; i++)
{
if (!activeWords.Contains(words[i].name))
{
unusedWordIndices.Add(i);
}
}
Learnable newLearnable = words[unusedWordIndices[UnityEngine.Random.Range(0, unusedWordIndices.Count)]];
Learnable newLearnable = words[unusedWordIndices[Random.Range(0, unusedWordIndices.Count)]];
string nextSymbol = newLearnable.name;
GameObject newSymbolObject = GameObject.Instantiate(symbolPrefab, symbolContainer);
GameObject newSymbolObject = GameObject.Instantiate(symbolPrefab, new Vector3(0, trackY, 0), Quaternion.identity, symbolContainer);
// Dynamically load appearance
Image image = newSymbolObject.GetComponent<Image>();
Image image = newSymbolObject.transform.Find("Image").GetComponent<Image>();
image.sprite = newLearnable.image;
image.rectTransform.sizeDelta = new Vector2(symbolSize, symbolSize);
// Place the word that the symbol represents under the image
TMP_Text text = newSymbolObject.GetComponentInChildren<TMP_Text>();
text.text = nextSymbol;
text.color = Color.black;
text.rectTransform.localPosition = new Vector3(0, -160, 0);
activeWords.Add(nextSymbol);
activeWords.Add(nextSymbol.ToUpper());
activeSymbols.Add(newSymbolObject);
}
/// <summary>
/// Update and save the scores
/// The logic to process the signs sent by the signPredictor
/// </summary>
public void SaveScores()
/// <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)
{
// Calculate new score
int newScore = this.score;
Learnable predSign = currentTheme.learnables.Find(l => l.name.ToUpper() == predictedSign);
// 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
user = userList.GetCurrentUser();
Progress progress = user.GetMinigameProgress(minigame.index);
// Get the current list of scores
List<Score> latestScores = progress.Get<List<Score>>("latestScores");
List<Score> highestScores = progress.Get<List<Score>>("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.AddOrUpdate<List<Score>>("latestScores", latestScores.Take(10).ToList());
progress.AddOrUpdate<List<Score>>("highestScores", highestScores.Take(10).ToList());
userList.Save();
}
/// <summary>
/// Set score metrics
/// </summary>
private void SetScoreMetrics()
{
// In de zone
perfectSignsText.text = perfectSigns.ToString();
// Aanvaardbaar
goodSignsText.text = goodSigns.ToString();
// Nipt
mehSignsText.text = mehSigns.ToString();
// Slechte timing
terribleSignsText.text = terribleSigns.ToString();
// Niet Geraden
notFoundSignsText.text = incorrectSigns.ToString();
// LPM
int duration = songList.songs[songList.currentSongIndex].duration;
int correctSigns = goodSigns + perfectSigns + mehSigns + terribleSigns;
lpmText.text = (60f * correctSigns / duration).ToString("#") + " GPM";
// Score
scoreText.text = "Score: " + score.ToString();
}
/// <summary>
/// Sets the scoreboard
/// </summary>
private void SetScoreBoard()
{
// Clean the previous scoreboard entries
for (int i = 0; i < scoreboardEntries.Count; i++)
// If there is a feedback-object, we wil change its appearance
if (feedbackText != null && feedbackProgressImage != null)
{
Destroy(scoreboardEntries[i]);
}
scoreboardEntries.Clear();
// Instantiate new entries
// Get all scores from all users
List<Tuple<string, Score>> allScores = new List<Tuple<string, Score>>();
foreach (User user in userList.GetUsers())
{
// Get user's progress for this minigame
Progress progress = user.GetMinigameProgress(minigame.index);
if (progress != null)
Color col;
if (accuracy > predSign.thresholdPercentage)
{
// Add scores to dictionary
List<Score> scores = progress.Get<List<Score>>("highestScores");
foreach (Score score in scores)
{
allScores.Add(new Tuple<string, Score>(user.username, score));
}
feedbackText.text = $"Herkent '{predictedSign}'";
col = new Color(0x8b / 255.0f, 0xd4 / 255.0f, 0x5e / 255.0f);
}
}
// Sort allScores based on Score.scoreValue
allScores.Sort((a, b) => b.Item2.scoreValue.CompareTo(a.Item2.scoreValue));
// Instantiate scoreboard entries
int rank = 1;
foreach (Tuple<string, Score> tup in allScores.Take(10))
{
string username = tup.Item1;
Score score = tup.Item2;
GameObject entry = Instantiate(scoreboardEntry, scoreboardEntriesContainer);
scoreboardEntries.Add(entry);
// Set the player icon
entry.transform.Find("Image").GetComponent<Image>().sprite = userList.GetUserByUsername(username).avatar;
// Set the player name
entry.transform.Find("PlayerName").GetComponent<TMP_Text>().text = username;
// Set the score
entry.transform.Find("Score").GetComponent<TMP_Text>().text = score.scoreValue.ToString();
// Set the rank
entry.transform.Find("Rank").GetComponent<TMP_Text>().text = rank.ToString();
// Set the ago
// Convert the score.time to Datetime
DateTime time = DateTime.Parse(score.time);
DateTime currentTime = DateTime.Now;
TimeSpan diff = currentTime.Subtract(time);
string formatted;
if (diff.Days > 0)
else if (accuracy > 0.9 * predSign.thresholdPercentage)
{
formatted = $"{diff.Days}d ";
}
else if (diff.Hours > 0)
{
formatted = $"{diff.Hours}h ";
}
else if (diff.Minutes > 0)
{
formatted = $"{diff.Minutes}m ";
feedbackText.text = $"Lijkt op '{predictedSign}'";
col = new Color(0xf2 / 255.0f, 0x7f / 255.0f, 0x0c / 255.0f);
}
else
{
formatted = "now";
feedbackText.text = "Detecteren...";
col = new Color(0xf5 / 255.0f, 0x49 / 255.0f, 0x3d / 255.0f);
}
entry.transform.Find("Ago").GetComponent<TMP_Text>().text = formatted;
feedbackText.color = col;
feedbackProgressImage.color = col;
// Alternating colors looks nice
if (rank % 2 == 0)
float oldValue = feedbackProgress.value;
// use an exponential scale
float newValue = Mathf.Exp(4 * (Mathf.Clamp(accuracy / predSign.thresholdPercentage, 0.0f, 1.0f) - 1.0f));
feedbackProgress.gameObject.Tween("FeedbackUpdate", oldValue, newValue, 0.2f, TweenScaleFunctions.CubicEaseInOut, (t) =>
{
Image image = entry.transform.GetComponent<Image>();
image.color = new Color(image.color.r, image.color.g, image.color.b, 0f);
}
if (feedbackProgress != null)
{
feedbackProgress.value = t.CurrentValue;
}
});
}
// Make new score stand out
if (diff.TotalSeconds < 1)
// The logic for the internal workings of the game
if (accuracy > predSign.thresholdPercentage)
{
int matchedSymbolIndex = activeWords.IndexOf(predictedSign.ToUpper());
// Destroy the oldest symbol if the current input matches it
if (0 <= matchedSymbolIndex)
{
Image image = entry.transform.GetComponent<Image>();
image.color = new Color(0, 229, 255, 233);
}
float x = activeSymbols[matchedSymbolIndex].transform.localPosition.x;
rank++;
// parameters to define the Perfect hit zone
float perfectRange = hitZonePerfect.sizeDelta.x;
float perfectCenter = hitZonePerfect.localPosition.x;
// parameters to define the Good hit zone
float goodRange = hitZoneGood.sizeDelta.x;
float goodCenter = hitZoneGood.localPosition.x;
// parameters to define the Meh hit zone
float mehRange = hitZoneMeh.sizeDelta.x;
float mehCenter = hitZoneMeh.localPosition.x;
if (perfectCenter - perfectRange / 2 <= x && x <= perfectCenter + perfectRange / 2)
{
timingFeedback.text = $"Perfect! \n +{perfectScore}";
imageFeedback.sprite = perfectSprite;
perfectSigns++;
timingFeedback.color = new Color(0x8b / 255.0f, 0xd4 / 255.0f, 0x5e / 255.0f);
}
else if (goodCenter - goodRange / 2 <= x && x <= goodCenter + goodRange / 2)
{
timingFeedback.text = $"Goed \n +{goodScore}";
imageFeedback.sprite = goodSprite;
goodSigns++;
timingFeedback.color = new Color(0xf7 / 255.0f, 0xad / 255.0f, 0x19 / 255.0f);
}
else if (mehCenter - mehRange / 2 <= x && x <= mehCenter + mehRange / 2)
{
timingFeedback.text = $"Bijna... \n +{mehScore}";
imageFeedback.sprite = mehSprite;
mehSigns++;
timingFeedback.color = new Color(0xf2 / 255.0f, 0x7f / 255.0f, 0x0c / 255.0f);
}
else
{
timingFeedback.text = $"Te vroeg! \n {terribleScore}";
imageFeedback.sprite = terribleSprite;
terribleSigns++;
timingFeedback.color = new Color(0xf5 / 255.0f, 0x49 / 255.0f, 0x3d / 255.0f);
}
DestroySymbolAt(matchedSymbolIndex);
}
}
}
/// <summary>
/// The logic to set the scoreboard of justsign
/// </summary>
/// <param name="victory">Shows whether or not the player won, is not relevant for JustSIgn</param>
protected override void SetScoreBoard(bool victory)
{
gameEndedPanel.GetComponent<JustSignGameEndedPanel>().GenerateContent(
perfectSigns: perfectSigns,
goodSigns: goodSigns,
mehSigns: mehSigns,
terribleSigns: terribleSigns,
incorrectSigns: incorrectSigns,
duration: currentSong.duration,
score: CalculateScore()
);
}
/// <summary>
/// The justsign-specific logic that needs to be called at the start of the game
/// </summary>
protected override void StartGameLogic()
{
// Set the current theme so that it can be passed along
currentTheme = minigame.themeList.themes[minigame.themeList.currentThemeIndex];
userFeedback.SetActive(currentTheme.modelIndex != ModelIndex.NONE);
previewMessage.SetActive(currentTheme.modelIndex == ModelIndex.NONE);
perfectSigns = 0;
goodSigns = 0;
mehSigns = 0;
terribleSigns = 0;
incorrectSigns = 0;
timingFeedback.text = "";
imageFeedback.sprite = minigame.thumbnail;
gameEndedPanel.SetActive(false);
scoreDisplay.text = $"Score: {CalculateScore()}";
words.AddRange(currentTheme.learnables);
currentSong = songList.songs[songList.currentSongIndex];
AudioSource.PlayClipAtPoint(currentSong.song, Vector3.zero, 1.0f);
beginTime = Time.time;
lastSymbolTime = beginTime + currentSong.duration - 1920.0f / moveSpeed;
StartCoroutine(WaitThenStart(currentSong.firstSymbolTime));
}
/// <summary>
/// The justsign-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;
while (activeSymbols.Count > 0)
{
DestroySymbolAt(0);
}
}
}