jongjae0305
c335995a9a
- SongSelectManager/SongDetailPanel: 곡 선택 및 상세 패널 개선 - SongCreatorManager: 곡 생성 기능 추가 - FinalScoreLabel/ScoreManager: 결과 화면 점수 UI 업데이트 - MarqueeText: 마퀴 텍스트 컴포넌트 개선 - NoteData/SongController: 노트 데이터 및 컨트롤러 보완 Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
650 lines
24 KiB
C#
650 lines
24 KiB
C#
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
using Platinio.TweenEngine;
|
|
using VRBeats.ScriptableEvents;
|
|
|
|
namespace VRBeats
|
|
{
|
|
public class ScoreManager : MonoBehaviour
|
|
{
|
|
private enum BeatJudgement
|
|
{
|
|
Perfect,
|
|
Great,
|
|
Good,
|
|
Miss
|
|
}
|
|
|
|
[SerializeField] private Text multiplierLabel = null;
|
|
[SerializeField] private Text scoreLabel = null;
|
|
[SerializeField] private Image multiplierLoader = null;
|
|
[SerializeField] private float scoreFollowTime = 1.0f;
|
|
[SerializeField] private CanvasGroup canvasGroup = null;
|
|
[SerializeField] private GameEvent onGameOver = null;
|
|
|
|
[Header("DJMAX Style Score")]
|
|
[SerializeField] private Text comboLabel = null;
|
|
[SerializeField] private Text accuracyLabel = null;
|
|
[SerializeField] private Text judgementLabel = null;
|
|
[SerializeField] private bool createMissingHudLabels = true;
|
|
[SerializeField] private bool applyHudPlacement = true;
|
|
[SerializeField] private Vector2 hudAnchoredPosition = new Vector2(0.0f, 1.65f);
|
|
[SerializeField] private float perfectWindow = 0.11f;
|
|
[SerializeField] private float greatWindow = 0.20f;
|
|
[SerializeField] private float goodWindow = 0.32f;
|
|
|
|
private int maxMultiplier = 0;
|
|
private const int MaxCourseScore = 1000000;
|
|
private const float ProgressBarWidth = 150.0f;
|
|
private float currentMultiplier = 1.0f;
|
|
private int acumulateErrors = 0;
|
|
private int errorLimit = 0;
|
|
private int totalNoteCount = 0;
|
|
private int judgedNoteCount = 0;
|
|
private int currentCombo = 0;
|
|
private int maxCombo = 0;
|
|
private int perfectCount = 0;
|
|
private int greatCount = 0;
|
|
private int goodCount = 0;
|
|
private int missCount = 0;
|
|
private int earnedAccuracyPoints = 0;
|
|
private float visualScore = 0.0f;
|
|
private int scoreTweenID = -1;
|
|
private int loaderTweenID = -1;
|
|
private BeatJudgement lastJudgement = BeatJudgement.Perfect;
|
|
private float judgementTimer = 0.0f;
|
|
private Text progressLabel = null;
|
|
private Text rankLabel = null;
|
|
private Image progressBarBackground = null;
|
|
private Image progressBarFill = null;
|
|
private Vector3 comboBaseScale = Vector3.one;
|
|
private float songCurrentTime = 0.0f;
|
|
private float songDuration = 0.0f;
|
|
private bool resultFinalized = false;
|
|
private bool destroyed = false;
|
|
|
|
private static bool hasPendingSliceTiming = false;
|
|
private static float pendingSliceTiming = 0.0f;
|
|
private static Font hudFont = null;
|
|
private Image ringBackground = null;
|
|
|
|
public int CurrentScore
|
|
{
|
|
get
|
|
{
|
|
float accuracyRatio = AccuracyPercent / 100.0f;
|
|
float comboRatio = totalNoteCount > 0
|
|
? maxCombo / (float)totalNoteCount
|
|
: 0.0f;
|
|
return Mathf.RoundToInt(800000.0f * accuracyRatio + 200000.0f * comboRatio);
|
|
}
|
|
}
|
|
public float AccuracyPercent
|
|
{
|
|
get
|
|
{
|
|
int denominatorNotes = totalNoteCount > 0 ? totalNoteCount : judgedNoteCount;
|
|
if (denominatorNotes <= 0)
|
|
return 100.0f;
|
|
|
|
return (float)earnedAccuracyPoints / (denominatorNotes * 1000) * 100.0f;
|
|
}
|
|
}
|
|
|
|
public string Rank
|
|
{
|
|
get
|
|
{
|
|
if (CurrentScore >= MaxCourseScore) return "M";
|
|
|
|
float accuracy = AccuracyPercent;
|
|
if (accuracy >= 98.0f) return "S+";
|
|
if (accuracy >= 95.0f) return "S";
|
|
if (accuracy >= 90.0f) return "A";
|
|
if (accuracy >= 80.0f) return "B";
|
|
if (accuracy >= 70.0f) return "C";
|
|
if (accuracy >= 60.0f) return "D";
|
|
return "F";
|
|
}
|
|
}
|
|
|
|
public int MaxCombo => maxCombo;
|
|
public string RankColorHex => GetRankColorHex();
|
|
|
|
private void Awake()
|
|
{
|
|
maxMultiplier = VR_BeatManager.instance.GameSettings.MaxMultiplier;
|
|
errorLimit = VR_BeatManager.instance.GameSettings.ErrorLimit;
|
|
|
|
if (multiplierLoader != null)
|
|
multiplierLoader.fillAmount = 0.0f;
|
|
|
|
canvasGroup ??= GetComponent<CanvasGroup>() ?? gameObject.AddComponent<CanvasGroup>();
|
|
PrepareHud();
|
|
}
|
|
|
|
public static void ReportSliceTiming(float timingErrorSeconds)
|
|
{
|
|
pendingSliceTiming = timingErrorSeconds;
|
|
hasPendingSliceTiming = true;
|
|
}
|
|
|
|
public static void ReportMiss()
|
|
{
|
|
hasPendingSliceTiming = false;
|
|
pendingSliceTiming = 0.0f;
|
|
}
|
|
|
|
public void SetTotalNotes(int noteCount)
|
|
{
|
|
totalNoteCount = Mathf.Max(0, noteCount);
|
|
resultFinalized = false;
|
|
UpdateScoreTween();
|
|
}
|
|
|
|
public void ApplyForcedResult(int noteCount, int perfect, int great, int good, int miss, int forcedMaxCombo)
|
|
{
|
|
totalNoteCount = Mathf.Max(0, noteCount);
|
|
perfectCount = Mathf.Max(0, perfect);
|
|
greatCount = Mathf.Max(0, great);
|
|
goodCount = Mathf.Max(0, good);
|
|
missCount = Mathf.Max(0, miss);
|
|
judgedNoteCount = perfectCount + greatCount + goodCount + missCount;
|
|
earnedAccuracyPoints = perfectCount * 1000 + greatCount * 900 + goodCount * 700;
|
|
maxCombo = Mathf.Clamp(forcedMaxCombo, 0, Mathf.Max(totalNoteCount, judgedNoteCount));
|
|
currentCombo = maxCombo;
|
|
currentMultiplier = missCount > 0 ? 1.0f : GetComboMultiplier(currentCombo);
|
|
lastJudgement = missCount > 0 ? BeatJudgement.Miss : BeatJudgement.Perfect;
|
|
judgementTimer = 0.45f;
|
|
resultFinalized = false;
|
|
UpdateScoreTween();
|
|
UpdateMultiplierLoaderValue();
|
|
}
|
|
|
|
public void CompleteSong()
|
|
{
|
|
if (resultFinalized)
|
|
return;
|
|
|
|
resultFinalized = true;
|
|
|
|
int missedUnjudgedNotes = Mathf.Max(0, totalNoteCount - judgedNoteCount);
|
|
if (missedUnjudgedNotes > 0)
|
|
{
|
|
missCount += missedUnjudgedNotes;
|
|
judgedNoteCount += missedUnjudgedNotes;
|
|
currentCombo = 0;
|
|
currentMultiplier = 1.0f;
|
|
}
|
|
|
|
UpdateScoreTween();
|
|
}
|
|
|
|
public void SetSongProgress(float currentTime, float duration)
|
|
{
|
|
songDuration = Mathf.Max(0.0f, duration);
|
|
songCurrentTime = songDuration > 0.0f
|
|
? Mathf.Clamp(currentTime, 0.0f, songDuration)
|
|
: Mathf.Max(0.0f, currentTime);
|
|
}
|
|
|
|
public void OnGameOver()
|
|
{
|
|
gameObject.CancelAllTweens();
|
|
if (canvasGroup != null)
|
|
{
|
|
canvasGroup.alpha = 0.0f;
|
|
canvasGroup.interactable = false;
|
|
canvasGroup.blocksRaycasts = false;
|
|
}
|
|
|
|
SetSaberVisibility(false);
|
|
}
|
|
|
|
public void OnGameRestart()
|
|
{
|
|
ResetThisComponent();
|
|
gameObject.CancelAllTweens();
|
|
if (canvasGroup != null)
|
|
{
|
|
canvasGroup.alpha = 1.0f;
|
|
canvasGroup.interactable = true;
|
|
canvasGroup.blocksRaycasts = false;
|
|
}
|
|
|
|
SetSaberVisibility(true);
|
|
}
|
|
|
|
public void ResetThisComponent()
|
|
{
|
|
currentMultiplier = 1.0f;
|
|
visualScore = 0;
|
|
acumulateErrors = 0;
|
|
judgedNoteCount = 0;
|
|
currentCombo = 0;
|
|
maxCombo = 0;
|
|
perfectCount = 0;
|
|
greatCount = 0;
|
|
goodCount = 0;
|
|
missCount = 0;
|
|
earnedAccuracyPoints = 0;
|
|
judgementTimer = 0.0f;
|
|
resultFinalized = false;
|
|
hasPendingSliceTiming = false;
|
|
pendingSliceTiming = 0.0f;
|
|
|
|
if (multiplierLoader != null)
|
|
multiplierLoader.fillAmount = 0.0f;
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
UpdateUI();
|
|
}
|
|
|
|
public void OnCorrectSlice()
|
|
{
|
|
if (destroyed)
|
|
return;
|
|
|
|
BeatJudgement judgement = ConsumeJudgement();
|
|
RegisterJudgement(judgement);
|
|
|
|
acumulateErrors = judgement == BeatJudgement.Miss ? acumulateErrors + 1 : 0;
|
|
|
|
UpdateScoreTween();
|
|
UpdateMultiplierLoaderValue();
|
|
}
|
|
|
|
public void OnIncorrectSlice()
|
|
{
|
|
if (destroyed)
|
|
return;
|
|
|
|
RegisterJudgement(BeatJudgement.Miss);
|
|
acumulateErrors++;
|
|
currentMultiplier = 1.0f;
|
|
|
|
UpdateScoreTween();
|
|
UpdateMultiplierLoaderValue();
|
|
|
|
if (acumulateErrors > errorLimit)
|
|
onGameOver.Invoke();
|
|
}
|
|
|
|
public string BuildResultSummary(int minScoreLength)
|
|
{
|
|
string score = CurrentScore.ToString("N0");
|
|
|
|
return $"<line-height=76%><size=300%><color={GetRankColorHex()}>{Rank}</color></size>" +
|
|
$"<pos=255><voffset=0.48em><size=92%>{score}</size></voffset>\n" +
|
|
$"<pos=255><size=72%><color=#D7F7FF>MAX COMBO {maxCombo}</color></size>";
|
|
}
|
|
|
|
private void CancelTweenById(int id)
|
|
{
|
|
if (id != -1)
|
|
PlatinioTween.instance.CancelTween(id);
|
|
}
|
|
|
|
private void UpdateMultiplierLoaderValue()
|
|
{
|
|
if (destroyed || multiplierLoader == null)
|
|
return;
|
|
|
|
float multiplierLoaderValue = GetComboTierProgress();
|
|
CancelTweenById(loaderTweenID);
|
|
loaderTweenID = PlatinioTween.instance.ValueTween(multiplierLoader.fillAmount, multiplierLoaderValue, 1.0f)
|
|
.SetEase(Ease.EaseOutExpo)
|
|
.SetOnUpdateFloat(delegate (float value)
|
|
{
|
|
if (multiplierLoader != null)
|
|
multiplierLoader.fillAmount = value;
|
|
})
|
|
.SetOwner(multiplierLoader.gameObject)
|
|
.ID;
|
|
}
|
|
|
|
private void UpdateScoreTween()
|
|
{
|
|
CancelTweenById(scoreTweenID);
|
|
scoreTweenID = PlatinioTween.instance.ValueTween(visualScore, CurrentScore, scoreFollowTime)
|
|
.SetEase(Ease.EaseOutExpo)
|
|
.SetOnUpdateFloat(delegate (float value) { visualScore = value; })
|
|
.ID;
|
|
}
|
|
|
|
private void UpdateUI()
|
|
{
|
|
if (destroyed)
|
|
return;
|
|
|
|
if (multiplierLabel != null)
|
|
multiplierLabel.text = $"x{Mathf.RoundToInt(currentMultiplier)}";
|
|
if (scoreLabel != null)
|
|
scoreLabel.text = $"{Mathf.CeilToInt(visualScore):N0}";
|
|
if (comboLabel != null)
|
|
comboLabel.text = currentCombo > 0
|
|
? $"<size=18><color=#E6F8FF>COMBO</color></size>\n<size=42>{currentCombo}</size>"
|
|
: "<size=18><color=#E6F8FF>COMBO</color></size>\n<size=42>0</size>";
|
|
if (accuracyLabel != null)
|
|
accuracyLabel.text = $"{AccuracyPercent:0.0}%";
|
|
if (rankLabel != null)
|
|
rankLabel.text = $"<color={GetRankColorHex()}>{Rank}</color>";
|
|
if (progressLabel != null)
|
|
progressLabel.text = songDuration > 0.0f
|
|
? $"{FormatTime(songCurrentTime)} / {FormatTime(songDuration)}"
|
|
: "";
|
|
if (progressBarFill != null)
|
|
SetProgressBarFill(songDuration > 0.0f
|
|
? Mathf.Clamp01(songCurrentTime / songDuration)
|
|
: 0.0f);
|
|
|
|
if (judgementLabel == null)
|
|
return;
|
|
|
|
judgementTimer -= Time.deltaTime;
|
|
judgementLabel.text = judgementTimer > 0.0f ? GetJudgementText(lastJudgement) : "";
|
|
judgementLabel.color = GetJudgementColor(lastJudgement);
|
|
}
|
|
|
|
private BeatJudgement ConsumeJudgement()
|
|
{
|
|
if (!hasPendingSliceTiming)
|
|
return BeatJudgement.Perfect;
|
|
|
|
float timing = pendingSliceTiming;
|
|
hasPendingSliceTiming = false;
|
|
pendingSliceTiming = 0.0f;
|
|
|
|
if (timing <= perfectWindow) return BeatJudgement.Perfect;
|
|
if (timing <= greatWindow) return BeatJudgement.Great;
|
|
if (timing <= goodWindow) return BeatJudgement.Good;
|
|
return BeatJudgement.Good;
|
|
}
|
|
|
|
private void RegisterJudgement(BeatJudgement judgement)
|
|
{
|
|
lastJudgement = judgement;
|
|
judgementTimer = 0.45f;
|
|
judgedNoteCount++;
|
|
|
|
if (judgement == BeatJudgement.Perfect)
|
|
{
|
|
perfectCount++;
|
|
earnedAccuracyPoints += 1000;
|
|
currentCombo++;
|
|
}
|
|
else if (judgement == BeatJudgement.Great)
|
|
{
|
|
greatCount++;
|
|
earnedAccuracyPoints += 900;
|
|
currentCombo++;
|
|
}
|
|
else if (judgement == BeatJudgement.Good)
|
|
{
|
|
goodCount++;
|
|
earnedAccuracyPoints += 700;
|
|
currentCombo++;
|
|
}
|
|
else
|
|
{
|
|
missCount++;
|
|
currentCombo = 0;
|
|
}
|
|
|
|
maxCombo = Mathf.Max(maxCombo, currentCombo);
|
|
currentMultiplier = judgement == BeatJudgement.Miss
|
|
? 1.0f
|
|
: Mathf.Min(GetComboMultiplier(currentCombo), Mathf.Max(1.0f, maxMultiplier));
|
|
|
|
PulseComboLabel(judgement);
|
|
}
|
|
|
|
private static float GetComboMultiplier(int combo)
|
|
{
|
|
if (combo >= 50) return 1.5f;
|
|
if (combo >= 30) return 1.35f;
|
|
if (combo >= 15) return 1.2f;
|
|
if (combo >= 5) return 1.1f;
|
|
return 1.0f;
|
|
}
|
|
|
|
private static string GetJudgementText(BeatJudgement judgement)
|
|
{
|
|
switch (judgement)
|
|
{
|
|
case BeatJudgement.Perfect: return "PERFECT";
|
|
case BeatJudgement.Great: return "GREAT";
|
|
case BeatJudgement.Good: return "GOOD";
|
|
default: return "BREAK";
|
|
}
|
|
}
|
|
|
|
private static Color GetJudgementColor(BeatJudgement judgement)
|
|
{
|
|
switch (judgement)
|
|
{
|
|
case BeatJudgement.Perfect: return new Color(0.25f, 0.95f, 1.0f, 1.0f);
|
|
case BeatJudgement.Great: return new Color(0.58f, 1.0f, 0.45f, 1.0f);
|
|
case BeatJudgement.Good: return new Color(1.0f, 0.8f, 0.35f, 1.0f);
|
|
default: return new Color(1.0f, 0.25f, 0.45f, 1.0f);
|
|
}
|
|
}
|
|
|
|
private float GetComboTierProgress()
|
|
{
|
|
int lower = 0;
|
|
int upper = 5;
|
|
if (currentCombo >= 50) return 1.0f;
|
|
if (currentCombo >= 30) { lower = 30; upper = 50; }
|
|
else if (currentCombo >= 15) { lower = 15; upper = 30; }
|
|
else if (currentCombo >= 5) { lower = 5; upper = 15; }
|
|
|
|
return Mathf.InverseLerp(lower, upper, currentCombo);
|
|
}
|
|
|
|
private void PrepareHud()
|
|
{
|
|
RectTransform rect = transform as RectTransform;
|
|
if (applyHudPlacement && rect != null)
|
|
rect.anchoredPosition = hudAnchoredPosition;
|
|
|
|
comboLabel = comboLabel != null ? comboLabel : FindHudText("Combo");
|
|
accuracyLabel = accuracyLabel != null ? accuracyLabel : FindHudText("Accuracy");
|
|
rankLabel = rankLabel != null ? rankLabel : FindHudText("Rank");
|
|
judgementLabel = judgementLabel != null ? judgementLabel : FindHudText("Judgement");
|
|
progressLabel = progressLabel != null ? progressLabel : FindHudText("SongProgress");
|
|
progressBarBackground = progressBarBackground != null ? progressBarBackground : FindHudImage("SongProgressBarBackground");
|
|
progressBarFill = progressBarFill != null ? progressBarFill : FindHudImage("SongProgressBarFill");
|
|
|
|
if (!createMissingHudLabels)
|
|
return;
|
|
|
|
comboLabel ??= CreateHudText("Combo");
|
|
accuracyLabel ??= CreateHudText("Accuracy");
|
|
rankLabel ??= CreateHudText("Rank");
|
|
judgementLabel ??= CreateHudText("Judgement");
|
|
progressLabel ??= CreateHudText("SongProgress");
|
|
progressBarBackground ??= CreateHudImage("SongProgressBarBackground");
|
|
progressBarFill ??= CreateHudImage("SongProgressBarFill");
|
|
ringBackground = ringBackground != null ? ringBackground : FindHudImage("MultiplierRingBg");
|
|
ringBackground ??= CreateHudImage("MultiplierRingBg");
|
|
|
|
ConfigureText(comboLabel, new Vector2(-335.0f, 92.0f), new Vector2(190.0f, 118.0f), 34, Color.white, TextAnchor.MiddleCenter);
|
|
ConfigureText(scoreLabel, new Vector2(-335.0f, 10.0f), new Vector2(190.0f, 42.0f), 22, Color.white, TextAnchor.MiddleCenter);
|
|
ConfigureText(accuracyLabel, new Vector2(-335.0f, -34.0f), new Vector2(190.0f, 32.0f), 18, new Color(0.84f, 0.94f, 1.0f, 1.0f), TextAnchor.MiddleCenter);
|
|
ConfigureText(rankLabel, new Vector2(-335.0f, -92.0f), new Vector2(190.0f, 72.0f), 48, Color.white, TextAnchor.MiddleCenter);
|
|
ConfigureText(judgementLabel, new Vector2(0.0f, 118.0f), new Vector2(280.0f, 56.0f), 28, new Color(0.25f, 0.95f, 1.0f, 1.0f), TextAnchor.MiddleCenter);
|
|
ConfigureText(multiplierLabel, new Vector2(335.0f, 38.0f), new Vector2(118.0f, 76.0f), 34, Color.white, TextAnchor.MiddleCenter);
|
|
ConfigureText(progressLabel, new Vector2(335.0f, -75.0f), new Vector2(180.0f, 30.0f), 17, Color.white, TextAnchor.MiddleCenter);
|
|
ConfigureImage(multiplierLoader, new Vector2(335.0f, 38.0f), new Vector2(112.0f, 112.0f), new Color(1.0f, 1.0f, 1.0f, 0.78f));
|
|
ConfigureImage(ringBackground, new Vector2(335.0f, 38.0f), new Vector2(112.0f, 112.0f), new Color(1.0f, 1.0f, 1.0f, 0.15f));
|
|
if (ringBackground != null && multiplierLoader != null)
|
|
{
|
|
ringBackground.sprite = multiplierLoader.sprite;
|
|
ringBackground.type = Image.Type.Simple;
|
|
ringBackground.transform.SetSiblingIndex(multiplierLoader.transform.GetSiblingIndex());
|
|
}
|
|
ConfigureImage(progressBarBackground, new Vector2(335.0f, -48.0f), new Vector2(ProgressBarWidth, 5.0f), new Color(1.0f, 1.0f, 1.0f, 0.22f));
|
|
ConfigureImage(progressBarFill, new Vector2(335.0f - ProgressBarWidth * 0.5f, -48.0f), new Vector2(ProgressBarWidth, 5.0f), Color.white);
|
|
if (progressBarFill != null)
|
|
{
|
|
RectTransform fillRect = progressBarFill.rectTransform;
|
|
fillRect.pivot = new Vector2(0.0f, 0.5f);
|
|
SetProgressBarFill(0.0f);
|
|
}
|
|
comboBaseScale = comboLabel != null ? comboLabel.transform.localScale : Vector3.one;
|
|
}
|
|
|
|
private Text CreateHudText(string name)
|
|
{
|
|
GameObject textObject = new GameObject(name);
|
|
textObject.layer = gameObject.layer;
|
|
textObject.transform.SetParent(transform, false);
|
|
|
|
RectTransform rect = textObject.AddComponent<RectTransform>();
|
|
textObject.AddComponent<CanvasRenderer>();
|
|
Text text = textObject.AddComponent<Text>();
|
|
return text;
|
|
}
|
|
|
|
private Image CreateHudImage(string name)
|
|
{
|
|
GameObject imageObject = new GameObject(name);
|
|
imageObject.layer = gameObject.layer;
|
|
imageObject.transform.SetParent(transform, false);
|
|
|
|
imageObject.AddComponent<CanvasRenderer>();
|
|
return imageObject.AddComponent<Image>();
|
|
}
|
|
|
|
private static void ConfigureText(Text text, Vector2 anchoredPosition, Vector2 size, int fontSize, Color color, TextAnchor alignment)
|
|
{
|
|
if (text == null)
|
|
return;
|
|
|
|
if (text.font == null)
|
|
text.font = HudFont;
|
|
|
|
RectTransform rect = text.rectTransform;
|
|
rect.anchorMin = new Vector2(0.5f, 0.5f);
|
|
rect.anchorMax = new Vector2(0.5f, 0.5f);
|
|
rect.anchoredPosition = anchoredPosition;
|
|
rect.sizeDelta = size;
|
|
|
|
text.fontSize = fontSize;
|
|
text.color = color;
|
|
text.alignment = alignment;
|
|
text.horizontalOverflow = HorizontalWrapMode.Overflow;
|
|
text.verticalOverflow = VerticalWrapMode.Overflow;
|
|
text.raycastTarget = false;
|
|
text.supportRichText = true;
|
|
text.lineSpacing = 0.86f;
|
|
|
|
Shadow shadow = text.GetComponent<Shadow>() ?? text.gameObject.AddComponent<Shadow>();
|
|
shadow.effectColor = new Color(0.0f, 0.0f, 0.0f, 0.72f);
|
|
shadow.effectDistance = new Vector2(3.0f, -3.0f);
|
|
}
|
|
|
|
private static void ConfigureImage(Image image, Vector2 anchoredPosition, Vector2 size)
|
|
{
|
|
ConfigureImage(image, anchoredPosition, size, new Color(1.0f, 1.0f, 1.0f, 0.85f));
|
|
}
|
|
|
|
private static void ConfigureImage(Image image, Vector2 anchoredPosition, Vector2 size, Color color)
|
|
{
|
|
if (image == null)
|
|
return;
|
|
|
|
RectTransform rect = image.rectTransform;
|
|
rect.anchorMin = new Vector2(0.5f, 0.5f);
|
|
rect.anchorMax = new Vector2(0.5f, 0.5f);
|
|
rect.anchoredPosition = anchoredPosition;
|
|
rect.sizeDelta = size;
|
|
image.color = color;
|
|
image.raycastTarget = false;
|
|
}
|
|
|
|
private void SetProgressBarFill(float progress)
|
|
{
|
|
if (progressBarFill == null)
|
|
return;
|
|
|
|
RectTransform rect = progressBarFill.rectTransform;
|
|
rect.sizeDelta = new Vector2(ProgressBarWidth * Mathf.Clamp01(progress), rect.sizeDelta.y);
|
|
}
|
|
|
|
private static Font HudFont
|
|
{
|
|
get
|
|
{
|
|
if (hudFont == null)
|
|
hudFont = Resources.GetBuiltinResource<Font>("LegacyRuntime.ttf");
|
|
|
|
return hudFont;
|
|
}
|
|
}
|
|
|
|
private Text FindHudText(string objectName)
|
|
{
|
|
Transform child = transform.Find(objectName);
|
|
return child != null ? child.GetComponent<Text>() : null;
|
|
}
|
|
|
|
private Image FindHudImage(string objectName)
|
|
{
|
|
Transform child = transform.Find(objectName);
|
|
return child != null ? child.GetComponent<Image>() : null;
|
|
}
|
|
|
|
private string GetRankColorHex()
|
|
{
|
|
switch (Rank)
|
|
{
|
|
case "M": return "#E8B7FF";
|
|
case "S+": return "#41F2FF";
|
|
case "S": return "#FFD95C";
|
|
case "A": return "#B9FF72";
|
|
case "B": return "#FFE06A";
|
|
case "C": return "#FFB15C";
|
|
case "D": return "#FF7C7C";
|
|
default: return "#A9B7C0";
|
|
}
|
|
}
|
|
|
|
private void PulseComboLabel(BeatJudgement judgement)
|
|
{
|
|
if (comboLabel == null || judgement == BeatJudgement.Miss)
|
|
return;
|
|
|
|
comboLabel.gameObject.CancelAllTweens();
|
|
comboLabel.transform.localScale = comboBaseScale * 1.08f;
|
|
comboLabel.transform.ScaleTween(comboBaseScale, 0.16f).SetEase(Ease.EaseOutExpo).SetOwner(comboLabel.gameObject);
|
|
}
|
|
|
|
private static string FormatTime(float seconds)
|
|
{
|
|
int wholeSeconds = Mathf.Max(0, Mathf.FloorToInt(seconds));
|
|
int minutes = wholeSeconds / 60;
|
|
int remainingSeconds = wholeSeconds % 60;
|
|
return $"{minutes}:{remainingSeconds:00}";
|
|
}
|
|
|
|
private static void SetSaberVisibility(bool visible)
|
|
{
|
|
VR_Saber[] sabers = FindObjectsByType<VR_Saber>(FindObjectsSortMode.None);
|
|
for (int i = 0; i < sabers.Length; i++)
|
|
{
|
|
if (sabers[i] == null)
|
|
continue;
|
|
|
|
if (visible)
|
|
sabers[i].MakeVisible();
|
|
else
|
|
sabers[i].MakeInvisible();
|
|
}
|
|
}
|
|
}
|
|
}
|