618 lines
21 KiB
C#
618 lines
21 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Timeline;
|
|
using UnityEngine.UI;
|
|
using TMPro;
|
|
using Jukebox;
|
|
using UnityEngine.Playables;
|
|
using UnityEngine.Networking;
|
|
using HeavenStudio.Games;
|
|
using HeavenStudio.InputSystem;
|
|
|
|
namespace HeavenStudio
|
|
{
|
|
[RequireComponent(typeof(PlayableDirector), typeof(AudioSource))]
|
|
public class JudgementManager : MonoBehaviour
|
|
{
|
|
enum Rank
|
|
{
|
|
Ng = 0,
|
|
Ok = 1,
|
|
Hi = 2
|
|
}
|
|
|
|
public enum InputCategory : int
|
|
{
|
|
Normal = 0,
|
|
Keep = 1,
|
|
Aim = 2,
|
|
Repeat = 3
|
|
// higher values are (will be) custom categories
|
|
}
|
|
|
|
[Serializable]
|
|
public struct MedalInfo
|
|
{
|
|
public double beat;
|
|
public string name;
|
|
public double score;
|
|
public bool cleared;
|
|
}
|
|
|
|
[Serializable]
|
|
public struct InputInfo
|
|
{
|
|
public double beat;
|
|
public double accuracyState;
|
|
public double timeOffset;
|
|
public float weight;
|
|
public int category;
|
|
}
|
|
|
|
[Serializable]
|
|
public struct JudgementInfo
|
|
{
|
|
public List<InputInfo> inputs;
|
|
public List<MedalInfo> medals;
|
|
|
|
public double finalScore;
|
|
public bool star, perfect;
|
|
public DateTime time;
|
|
}
|
|
|
|
const string MessageAdd = "Also... ";
|
|
|
|
static JudgementInfo judgementInfo;
|
|
static RiqBeatmap playedBeatmap;
|
|
|
|
public static void SetPlayInfo(JudgementInfo info, RiqBeatmap beatmap)
|
|
{
|
|
judgementInfo = info;
|
|
playedBeatmap = beatmap;
|
|
}
|
|
|
|
[Header("Bar parameters")]
|
|
[SerializeField] float barDuration;
|
|
[SerializeField] float barRankWait;
|
|
[SerializeField] float rankMusWait;
|
|
[SerializeField] Color barColourNg, barColourOk, barColourHi;
|
|
[SerializeField] Color numColourNg, numColourOk, numColourHi;
|
|
|
|
[Header("Audio clips")]
|
|
[SerializeField] AudioClip messageMid;
|
|
[SerializeField] AudioClip messageLast;
|
|
[SerializeField] AudioClip barLoop, barStop;
|
|
[SerializeField] AudioClip rankNg, rankOk, rankHi;
|
|
[SerializeField] AudioClip musNgStart, musOkStart, musHiStart;
|
|
[SerializeField] AudioClip musNg, musOk, musHi;
|
|
[SerializeField] AudioClip jglNg, jglOk, jglHi;
|
|
|
|
[Header("References")]
|
|
[SerializeField] TMP_Text header;
|
|
[SerializeField] TMP_Text message0;
|
|
[SerializeField] TMP_Text message1;
|
|
[SerializeField] TMP_Text message2;
|
|
[SerializeField] TMP_Text barText;
|
|
[SerializeField] Slider barSlider;
|
|
|
|
[SerializeField] TMP_Text epilogueMessage;
|
|
[SerializeField] Image epilogueImage;
|
|
[SerializeField] Image epilogueFrame;
|
|
[SerializeField] AspectRatioFitter epilogueFitter;
|
|
[SerializeField] Sprite epilogueNg, epilogueOk, epilogueHi;
|
|
[SerializeField] Sprite epilogueFrmNg, epilogueFrmOk, epilogueFrmHi;
|
|
|
|
[SerializeField] GameObject bg;
|
|
[SerializeField] GameObject rankLogo;
|
|
[SerializeField] TMP_Text justOk;
|
|
[SerializeField] Animator rankAnim;
|
|
[SerializeField] ParticleSystem okParticles1, okParticles2;
|
|
[SerializeField] CanvasScaler scaler;
|
|
[SerializeField] Animator canvasAnim;
|
|
|
|
AudioSource audioSource;
|
|
List<int> usedCategories;
|
|
float[] categoryInputs;
|
|
double[] categoryScores;
|
|
string msg0, msg1, msg2;
|
|
float barTime = 0, barStartTime = float.MaxValue;
|
|
Rank rank;
|
|
bool twoMessage = false, barStarted = false, didRank = false, didEpilogue = false, subRank = false;
|
|
|
|
public void PrepareJudgement()
|
|
{
|
|
bg.SetActive(false);
|
|
rankLogo.SetActive(false);
|
|
justOk.gameObject.SetActive(false);
|
|
subRank = false;
|
|
|
|
barText.text = "0";
|
|
barSlider.value = 0;
|
|
barText.color = numColourNg;
|
|
barSlider.fillRect.GetComponent<Image>().color = barColourNg;
|
|
|
|
string propSuffix = "ng";
|
|
if (judgementInfo.finalScore < Minigame.rankOkThreshold)
|
|
{
|
|
rank = Rank.Ng;
|
|
propSuffix = "ng";
|
|
}
|
|
else if (judgementInfo.finalScore < Minigame.rankHiThreshold)
|
|
{
|
|
rank = Rank.Ok;
|
|
propSuffix = "ok";
|
|
}
|
|
else
|
|
{
|
|
rank = Rank.Hi;
|
|
propSuffix = "hi";
|
|
}
|
|
|
|
GetCategoryInfo();
|
|
|
|
int firstCat = 0, secondCat = 0;
|
|
double lastScore = 0;
|
|
if (usedCategories.Count == 1)
|
|
{
|
|
twoMessage = false;
|
|
if (playedBeatmap != null)
|
|
{
|
|
msg0 = playedBeatmap[$"resultcommon_{propSuffix}"];
|
|
}
|
|
else
|
|
{
|
|
msg0 = rank switch
|
|
{
|
|
Rank.Ng => "Try harder next time.",
|
|
Rank.Ok => "Eh. Passable.",
|
|
_ => "Good rhythm.",
|
|
};
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (rank)
|
|
{
|
|
case Rank.Ok:
|
|
// check if any category has a hi score
|
|
foreach (int cat in usedCategories)
|
|
{
|
|
if (categoryScores[cat] > lastScore)
|
|
{
|
|
lastScore = categoryScores[cat];
|
|
firstCat = cat;
|
|
}
|
|
}
|
|
SetOkMessages(firstCat, lastScore);
|
|
break;
|
|
case Rank.Ng:
|
|
// find the first and second worst categories
|
|
firstCat = -1;
|
|
secondCat = -1;
|
|
lastScore = double.MaxValue;
|
|
foreach (int cat in usedCategories)
|
|
{
|
|
if (categoryScores[cat] < lastScore)
|
|
{
|
|
lastScore = categoryScores[cat];
|
|
firstCat = cat;
|
|
}
|
|
}
|
|
lastScore = double.MaxValue;
|
|
foreach (int cat in usedCategories)
|
|
{
|
|
if (cat == firstCat) continue;
|
|
if (categoryScores[cat] < lastScore)
|
|
{
|
|
lastScore = categoryScores[cat];
|
|
secondCat = cat;
|
|
}
|
|
}
|
|
// only show one message if only one category fails
|
|
twoMessage = categoryScores[secondCat] < Minigame.rankOkThreshold;
|
|
if (playedBeatmap != null)
|
|
{
|
|
msg0 = msg1 = playedBeatmap[$"resultcat{firstCat}_ng"];
|
|
msg2 = playedBeatmap[$"resultcat{secondCat}_ng"];
|
|
}
|
|
else
|
|
{
|
|
msg0 = msg1 = "Try harder next time.";
|
|
msg2 = "Try harder next time.";
|
|
}
|
|
break;
|
|
case Rank.Hi:
|
|
// find the first and second best categories
|
|
firstCat = -1;
|
|
secondCat = -1;
|
|
lastScore = 0;
|
|
foreach (int cat in usedCategories)
|
|
{
|
|
if (categoryScores[cat] > lastScore)
|
|
{
|
|
lastScore = categoryScores[cat];
|
|
firstCat = cat;
|
|
}
|
|
}
|
|
lastScore = 0;
|
|
foreach (int cat in usedCategories)
|
|
{
|
|
if (cat == firstCat) continue;
|
|
if (categoryScores[cat] > lastScore)
|
|
{
|
|
lastScore = categoryScores[cat];
|
|
secondCat = cat;
|
|
}
|
|
}
|
|
// only show one message if only one category passes
|
|
twoMessage = categoryScores[secondCat] >= Minigame.rankHiThreshold;
|
|
if (playedBeatmap != null)
|
|
{
|
|
msg0 = msg1 = playedBeatmap[$"resultcat{firstCat}_hi"];
|
|
msg2 = playedBeatmap[$"resultcat{secondCat}_hi"];
|
|
}
|
|
else
|
|
{
|
|
msg0 = msg1 = "Good rhythm.";
|
|
msg2 = "Good rhythm.";
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
header.text = playedBeatmap != null ? playedBeatmap["resultcaption"] : "Rhythm League Notes";
|
|
|
|
if (twoMessage)
|
|
{
|
|
message0.gameObject.SetActive(false);
|
|
message1.gameObject.SetActive(true);
|
|
message2.gameObject.SetActive(true);
|
|
message1.text = " ";
|
|
message2.text = " ";
|
|
}
|
|
else
|
|
{
|
|
message0.gameObject.SetActive(true);
|
|
message1.gameObject.SetActive(false);
|
|
message2.gameObject.SetActive(false);
|
|
message0.text = " ";
|
|
}
|
|
|
|
string imagePath;
|
|
string imageName;
|
|
EntityTypes.Resource? imageResource;
|
|
if (rank == Rank.Ng)
|
|
{
|
|
imageResource = playedBeatmap != null ? playedBeatmap["epilogue_ng_res"] : null;
|
|
}
|
|
else if (rank == Rank.Ok)
|
|
{
|
|
imageResource = playedBeatmap != null ? playedBeatmap["epilogue_ok_res"] : null;
|
|
}
|
|
else
|
|
{
|
|
imageResource = playedBeatmap != null ? playedBeatmap["epilogue_hi_res"] : null;
|
|
}
|
|
|
|
epilogueFrame.sprite = rank switch
|
|
{
|
|
Rank.Ok => epilogueFrmOk,
|
|
Rank.Hi => epilogueFrmHi,
|
|
_ => epilogueFrmNg
|
|
};
|
|
|
|
if (imageResource != null)
|
|
{
|
|
imagePath = imageResource.Value.path;
|
|
imageName = imageResource.Value.name;
|
|
try
|
|
{
|
|
string fsPath = RiqFileHandler.GetResourcePath(imageName, imagePath);
|
|
// fetch the image using UnityWebRequest
|
|
StartCoroutine(LoadImage(fsPath));
|
|
}
|
|
catch (System.IO.DirectoryNotFoundException)
|
|
{
|
|
Debug.Log("image resource doesn't exist, using blank placeholder");
|
|
epilogueImage.sprite = rank switch
|
|
{
|
|
Rank.Ok => epilogueOk,
|
|
Rank.Hi => epilogueHi,
|
|
_ => epilogueNg
|
|
};
|
|
epilogueFitter.aspectRatio = 16f / 9f;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SetOkMessages(int cat, double score)
|
|
{
|
|
twoMessage = false;
|
|
if (score >= Minigame.rankHiThreshold)
|
|
{
|
|
// just OK
|
|
subRank = true;
|
|
if (playedBeatmap != null)
|
|
{
|
|
msg0 = playedBeatmap[$"resultcat{cat}_hi"];
|
|
}
|
|
else
|
|
{
|
|
msg0 = "Good rhythm.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (playedBeatmap != null)
|
|
{
|
|
msg0 = playedBeatmap[$"resultcommon_ok"];
|
|
}
|
|
else
|
|
{
|
|
msg0 = "Eh. Passable.";
|
|
}
|
|
}
|
|
}
|
|
|
|
void GetCategoryInfo()
|
|
{
|
|
int maxCat = 0;
|
|
usedCategories = new();
|
|
if (playedBeatmap == null || playedBeatmap.data.beatmapSections.Count == 0)
|
|
{
|
|
usedCategories.Add(0);
|
|
return;
|
|
}
|
|
foreach (var section in playedBeatmap.data.beatmapSections)
|
|
{
|
|
int cat = section["category"];
|
|
if (!usedCategories.Contains(cat))
|
|
{
|
|
usedCategories.Add(cat);
|
|
maxCat = Mathf.Max(maxCat, cat);
|
|
}
|
|
}
|
|
usedCategories.Sort();
|
|
|
|
categoryInputs = new float[maxCat + 1];
|
|
categoryScores = new double[maxCat + 1];
|
|
foreach (var input in judgementInfo.inputs)
|
|
{
|
|
categoryInputs[input.category] += input.weight;
|
|
categoryScores[input.category] += input.accuracyState * input.weight;
|
|
}
|
|
for (int i = 0; i < categoryScores.Length; i++)
|
|
{
|
|
if (categoryInputs[i] > 0)
|
|
{
|
|
categoryScores[i] /= categoryInputs[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
IEnumerator LoadImage(string path)
|
|
{
|
|
UnityWebRequest www = UnityWebRequestTexture.GetTexture("file://" + path);
|
|
yield return www.SendWebRequest();
|
|
|
|
if (www.result == UnityWebRequest.Result.ConnectionError)
|
|
{
|
|
Debug.Log(www.error);
|
|
epilogueImage.sprite = rank switch
|
|
{
|
|
Rank.Ok => epilogueOk,
|
|
Rank.Hi => epilogueHi,
|
|
_ => epilogueNg
|
|
};
|
|
epilogueFitter.aspectRatio = 16f / 9f;
|
|
}
|
|
else
|
|
{
|
|
Texture2D texture = DownloadHandlerTexture.GetContent(www);
|
|
epilogueImage.sprite = Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height), new Vector2(0.5f, 0.5f));
|
|
epilogueImage.preserveAspect = true;
|
|
epilogueFitter.aspectRatio = (float)texture.width / (float)texture.height;
|
|
}
|
|
}
|
|
|
|
public void ShowMessage0()
|
|
{
|
|
if (twoMessage) return;
|
|
audioSource.PlayOneShot(messageLast);
|
|
message0.text = msg0;
|
|
}
|
|
|
|
public void ShowMessage1()
|
|
{
|
|
if (!twoMessage) return;
|
|
audioSource.PlayOneShot(messageMid);
|
|
// message1.text = "message line 1";
|
|
message1.text = msg1;
|
|
}
|
|
|
|
public void ShowMessage2()
|
|
{
|
|
if (!twoMessage) return;
|
|
audioSource.PlayOneShot(messageLast);
|
|
// message2.text = "message line 2";
|
|
message2.text = MessageAdd + msg2;
|
|
}
|
|
|
|
public void StartBar()
|
|
{
|
|
audioSource.clip = barLoop;
|
|
audioSource.Play();
|
|
|
|
barStartTime = Time.time;
|
|
barTime = (float)judgementInfo.finalScore * barDuration;
|
|
|
|
barStarted = true;
|
|
}
|
|
|
|
public void ShowRank()
|
|
{
|
|
rankLogo.SetActive(true);
|
|
// bg.SetActive(true);
|
|
if (rank == Rank.Ng)
|
|
{
|
|
rankAnim.Play("Ng");
|
|
audioSource.PlayOneShot(rankNg);
|
|
}
|
|
else if (rank == Rank.Ok)
|
|
{
|
|
rankAnim.Play("Ok");
|
|
if (subRank)
|
|
{
|
|
justOk.gameObject.SetActive(true);
|
|
justOk.text = "...but, just";
|
|
}
|
|
audioSource.PlayOneShot(rankOk);
|
|
}
|
|
else
|
|
{
|
|
rankAnim.Play("Hi");
|
|
audioSource.PlayOneShot(rankHi);
|
|
}
|
|
}
|
|
|
|
public void StartRankMusic()
|
|
{
|
|
if (rank == Rank.Ng)
|
|
{
|
|
audioSource.PlayOneShot(musNgStart);
|
|
audioSource.clip = musNg;
|
|
audioSource.loop = true;
|
|
audioSource.PlayScheduled(AudioSettings.dspTime + musNgStart.length);
|
|
}
|
|
else if (rank == Rank.Ok)
|
|
{
|
|
audioSource.PlayOneShot(musOkStart);
|
|
audioSource.clip = musOk;
|
|
audioSource.loop = true;
|
|
audioSource.PlayScheduled(AudioSettings.dspTime + musOkStart.length);
|
|
}
|
|
else
|
|
{
|
|
audioSource.PlayOneShot(musHiStart);
|
|
audioSource.clip = musHi;
|
|
audioSource.loop = true;
|
|
audioSource.PlayScheduled(AudioSettings.dspTime + musHiStart.length);
|
|
}
|
|
didRank = true;
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
audioSource = GetComponent<AudioSource>();
|
|
}
|
|
|
|
private IEnumerator WaitAndRank()
|
|
{
|
|
yield return new WaitForSeconds(barRankWait);
|
|
ShowRank();
|
|
yield return new WaitForSeconds(rankMusWait);
|
|
StartRankMusic();
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
float w = Screen.width / 1920f;
|
|
float h = Screen.height / 1080f;
|
|
scaler.scaleFactor = Mathf.Min(w, h);
|
|
|
|
InputController currentController = PlayerInput.GetInputController(1);
|
|
if (currentController.GetLastButtonDown() > 0)
|
|
{
|
|
if (didRank && !didEpilogue)
|
|
{
|
|
// start the sequence for epilogue
|
|
okParticles1.Stop();
|
|
okParticles2.Stop();
|
|
canvasAnim.Play("EpilogueOpen");
|
|
audioSource.Stop();
|
|
if (rank == Rank.Ng)
|
|
{
|
|
epilogueMessage.text = playedBeatmap != null ? playedBeatmap["epilogue_ng"] : "Try Again picture";
|
|
audioSource.PlayOneShot(jglNg);
|
|
}
|
|
else if (rank == Rank.Ok)
|
|
{
|
|
epilogueMessage.text = playedBeatmap != null ? playedBeatmap["epilogue_ok"] : "OK picture";
|
|
audioSource.PlayOneShot(jglOk);
|
|
}
|
|
else
|
|
{
|
|
epilogueMessage.text = playedBeatmap != null ? playedBeatmap["epilogue_hi"] : "Superb picture";
|
|
audioSource.PlayOneShot(jglHi);
|
|
}
|
|
didEpilogue = true;
|
|
}
|
|
else if (didEpilogue)
|
|
{
|
|
audioSource.Stop();
|
|
RiqFileHandler.ClearCache();
|
|
GlobalGameManager.LoadScene("Title", 0.35f, 0.5f);
|
|
}
|
|
else if (barStarted)
|
|
{
|
|
barTime = Time.time - barStartTime;
|
|
}
|
|
}
|
|
if (barStarted)
|
|
{
|
|
float t = Time.time - barStartTime;
|
|
if (t >= barTime)
|
|
{
|
|
barStarted = false;
|
|
audioSource.Stop();
|
|
audioSource.PlayOneShot(barStop);
|
|
barText.text = ((int)(judgementInfo.finalScore * 100)).ToString();
|
|
barSlider.value = (float)judgementInfo.finalScore;
|
|
|
|
if (rank == Rank.Ng)
|
|
{
|
|
barText.color = numColourNg;
|
|
barSlider.fillRect.GetComponent<Image>().color = barColourNg;
|
|
}
|
|
else if (rank == Rank.Ok)
|
|
{
|
|
barText.color = numColourOk;
|
|
barSlider.fillRect.GetComponent<Image>().color = barColourOk;
|
|
}
|
|
else
|
|
{
|
|
barText.color = numColourHi;
|
|
barSlider.fillRect.GetComponent<Image>().color = barColourHi;
|
|
}
|
|
|
|
StartCoroutine(WaitAndRank());
|
|
}
|
|
else
|
|
{
|
|
float v = t / barTime * (float)judgementInfo.finalScore;
|
|
barText.text = ((int)(v * 100)).ToString();
|
|
barSlider.value = v;
|
|
|
|
if (v < Minigame.rankOkThreshold)
|
|
{
|
|
barText.color = numColourNg;
|
|
barSlider.fillRect.GetComponent<Image>().color = barColourNg;
|
|
}
|
|
else if (v < Minigame.rankHiThreshold)
|
|
{
|
|
barText.color = numColourOk;
|
|
barSlider.fillRect.GetComponent<Image>().color = barColourOk;
|
|
}
|
|
else
|
|
{
|
|
barText.color = numColourHi;
|
|
barSlider.fillRect.GetComponent<Image>().color = barColourHi;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
} |