1938 lines
58 KiB
C#
1938 lines
58 KiB
C#
using System;
|
||
using System.Collections;
|
||
using System.Collections.Generic;
|
||
using System.Globalization;
|
||
using Bansonic;
|
||
using GameServer.Client;
|
||
using UnityEngine;
|
||
using UnityEngine.EventSystems;
|
||
using UnityEngine.UI;
|
||
|
||
public class roomDetails : MonoBehaviour
|
||
{
|
||
private sealed class RoomSystemFeedEntry
|
||
{
|
||
public string richText;
|
||
public long createdAtUnixMs;
|
||
public long sequence;
|
||
}
|
||
|
||
private sealed class RoomFeedEntry
|
||
{
|
||
public object entry;
|
||
public long timestampMs;
|
||
public int order;
|
||
public string key;
|
||
public long sequence;
|
||
}
|
||
|
||
[Header("room Info")]
|
||
public Text roomID;
|
||
public Text roomRemainTime;
|
||
public Button quitRoom;
|
||
public Button quitRoom2;
|
||
public Button getReady;
|
||
public Button showRoomRankingList;
|
||
|
||
[Header("song info")]
|
||
public Text thisSongName;
|
||
public Text thisSongDifficulty;
|
||
|
||
[Header("change songs")]
|
||
public Dropdown songDropdown;
|
||
public Dropdown difficultyDropdown;
|
||
|
||
[Header("objs")]
|
||
public GameObject roommatePrefab;
|
||
public Transform roommateParent;
|
||
|
||
[Header("sprites")]
|
||
public Sprite[] btmSprites;
|
||
|
||
[Header("roomChatSystem")]
|
||
public GameObject playerMessagePrefab;
|
||
public GameObject selfMessagePrefab;
|
||
public GameObject systemMessagePrefab;
|
||
public Transform messageParent;
|
||
[SerializeField] private int maxMessageHistory = 500;
|
||
[SerializeField] private int messageDisplayWindow = 20;
|
||
[SerializeField] private Color[] messageTypeColors;
|
||
public InputField playerMessageInputField;
|
||
public Button sendMessageButton;
|
||
|
||
private ArenaRoomService _service;
|
||
private Coroutine _countdownRoutine;
|
||
private GameObject _roomRankingPrefabTemplate;
|
||
private Transform _roomRankingSpawnParent;
|
||
private GameObject _spawnedRoomRankingInstance;
|
||
private ScrollRect _messageScrollRect;
|
||
private Coroutine _chatCooldownRoutine;
|
||
private Text _chatPlaceholderText;
|
||
private string _defaultChatPlaceholder = string.Empty;
|
||
private float _nextChatSendAllowedAt;
|
||
private bool _isSendingRoomMessage;
|
||
private string _pendingRoomMessageContent = string.Empty;
|
||
private readonly List<RoomSystemFeedEntry> _systemFeedEntries = new List<RoomSystemFeedEntry>();
|
||
private readonly Dictionary<string, long> _feedSequences = new Dictionary<string, long>(StringComparer.Ordinal);
|
||
private long _nextFeedSequence;
|
||
private bool _isChatViewPinnedToBottom = true;
|
||
private bool _suppressChatScrollEvents;
|
||
private int _chatWindowStartIndex = -1;
|
||
private readonly List<string> _renderedChatKeys = new List<string>();
|
||
private readonly List<GameObject> _renderedChatObjects = new List<GameObject>();
|
||
private Coroutine _messageLayoutRefreshCoroutine;
|
||
private bool _messageLayoutRefreshDirty;
|
||
private bool _scrollChatToBottomAfterLayout;
|
||
private readonly List<RectTransform> _pendingMessageLayoutDirtyRoots = new List<RectTransform>();
|
||
private Coroutine _refocusChatInputCoroutine;
|
||
private bool _refocusChatInputRequested;
|
||
private readonly List<SongData> _selectableSongs = new List<SongData>();
|
||
private readonly List<int> _selectableDifficulties = new List<int>();
|
||
private Coroutine _songLibraryWaitRoutine;
|
||
private bool _suppressSongDropdownEvents;
|
||
private bool _isChangingRoomSong;
|
||
private bool _isClosingSelf;
|
||
|
||
private const float ChatSendCooldownSeconds = 3f;
|
||
private const int InitialHistoryLoadLimit = 20;
|
||
private const int MaxDisplayWindowLimit = 20;
|
||
private const string CooldownPlaceholderFormat = "\u53d1\u9001\u51b7\u5374\u4e2d {0}s";
|
||
|
||
private void Awake()
|
||
{
|
||
EnsurePopupTween();
|
||
}
|
||
|
||
public void ConfigureRoomRanking(GameObject roomRankingPrefab, Transform roomRankingSpawnParent)
|
||
{
|
||
_roomRankingPrefabTemplate = roomRankingPrefab;
|
||
_roomRankingSpawnParent = roomRankingSpawnParent;
|
||
}
|
||
|
||
public void Bind(ArenaRoomService service)
|
||
{
|
||
EnsurePopupTween();
|
||
|
||
_service = service;
|
||
|
||
UIBackStack.RegisterOrBump(
|
||
this,
|
||
() => this != null && gameObject != null && gameObject.activeInHierarchy,
|
||
() =>
|
||
{
|
||
if (_spawnedRoomRankingInstance != null)
|
||
{
|
||
CloseRoomRankingWithExitAnim();
|
||
return true;
|
||
}
|
||
|
||
CloseSelfWithExitAnim();
|
||
return true;
|
||
});
|
||
|
||
if (_service == null)
|
||
{
|
||
Debug.LogWarning("[roomDetails] ArenaRoomService is missing.");
|
||
return;
|
||
}
|
||
|
||
_service.OnRoomSnapshotChanged -= HandleRoomSnapshotChanged;
|
||
_service.OnRoomSnapshotChanged += HandleRoomSnapshotChanged;
|
||
_service.OnKicked -= HandleKicked;
|
||
_service.OnKicked += HandleKicked;
|
||
_service.OnRoomDismissed -= HandleRoomDismissed;
|
||
_service.OnRoomDismissed += HandleRoomDismissed;
|
||
_service.OnRoomChatMessagesChanged -= HandleRoomChatMessagesChanged;
|
||
_service.OnRoomChatMessagesChanged += HandleRoomChatMessagesChanged;
|
||
_service.OnRoomSystemMessageReceived -= HandleRoomSystemMessageReceived;
|
||
_service.OnRoomSystemMessageReceived += HandleRoomSystemMessageReceived;
|
||
|
||
if (quitRoom != null)
|
||
{
|
||
quitRoom.onClick.RemoveListener(OnQuitClicked);
|
||
quitRoom.onClick.AddListener(OnQuitClicked);
|
||
}
|
||
|
||
if (quitRoom2 != null)
|
||
{
|
||
quitRoom2.onClick.RemoveListener(OnQuitClicked);
|
||
quitRoom2.onClick.AddListener(OnQuitClicked);
|
||
}
|
||
|
||
if (getReady != null)
|
||
{
|
||
getReady.onClick.RemoveListener(OnReadyButtonClicked);
|
||
getReady.onClick.AddListener(OnReadyButtonClicked);
|
||
}
|
||
|
||
if (showRoomRankingList != null)
|
||
{
|
||
showRoomRankingList.onClick.RemoveListener(OnShowRoomRankingClicked);
|
||
showRoomRankingList.onClick.AddListener(OnShowRoomRankingClicked);
|
||
}
|
||
|
||
if (sendMessageButton != null)
|
||
{
|
||
sendMessageButton.onClick.RemoveListener(OnSendMessageClicked);
|
||
sendMessageButton.onClick.AddListener(OnSendMessageClicked);
|
||
}
|
||
|
||
if (songDropdown != null)
|
||
{
|
||
songDropdown.onValueChanged.RemoveListener(OnSongDropdownChanged);
|
||
songDropdown.onValueChanged.AddListener(OnSongDropdownChanged);
|
||
}
|
||
|
||
if (difficultyDropdown != null)
|
||
{
|
||
difficultyDropdown.onValueChanged.RemoveListener(OnDifficultyDropdownChanged);
|
||
difficultyDropdown.onValueChanged.AddListener(OnDifficultyDropdownChanged);
|
||
}
|
||
|
||
if (playerMessageInputField != null)
|
||
{
|
||
playerMessageInputField.onEndEdit.RemoveListener(OnChatInputEndEdit);
|
||
playerMessageInputField.onEndEdit.AddListener(OnChatInputEndEdit);
|
||
_chatPlaceholderText = playerMessageInputField.placeholder as Text;
|
||
if (_chatPlaceholderText != null)
|
||
{
|
||
_defaultChatPlaceholder = _chatPlaceholderText.text;
|
||
}
|
||
}
|
||
|
||
_messageScrollRect = messageParent != null ? messageParent.GetComponentInParent<ScrollRect>() : null;
|
||
if (_messageScrollRect != null)
|
||
{
|
||
_messageScrollRect.onValueChanged.RemoveListener(OnChatScrollValueChanged);
|
||
_messageScrollRect.onValueChanged.AddListener(OnChatScrollValueChanged);
|
||
}
|
||
_service.SetRoomChatCacheLimit(GetEffectiveCacheLimit());
|
||
ClearDisplayedMessages();
|
||
UpdateChatSendUiState();
|
||
_ = InitializeRoomChatAsync();
|
||
|
||
Refresh(_service.CurrentRoom);
|
||
EnsureSongDropdownsReady();
|
||
}
|
||
|
||
private void OnDestroy()
|
||
{
|
||
UIBackStack.Unregister(this);
|
||
|
||
if (_service != null)
|
||
{
|
||
_service.OnRoomSnapshotChanged -= HandleRoomSnapshotChanged;
|
||
_service.OnKicked -= HandleKicked;
|
||
_service.OnRoomDismissed -= HandleRoomDismissed;
|
||
_service.OnRoomChatMessagesChanged -= HandleRoomChatMessagesChanged;
|
||
_service.OnRoomSystemMessageReceived -= HandleRoomSystemMessageReceived;
|
||
}
|
||
|
||
if (quitRoom != null)
|
||
{
|
||
quitRoom.onClick.RemoveListener(OnQuitClicked);
|
||
}
|
||
|
||
if (quitRoom2 != null)
|
||
{
|
||
quitRoom2.onClick.RemoveListener(OnQuitClicked);
|
||
}
|
||
|
||
if (getReady != null)
|
||
{
|
||
getReady.onClick.RemoveListener(OnReadyButtonClicked);
|
||
}
|
||
|
||
if (showRoomRankingList != null)
|
||
{
|
||
showRoomRankingList.onClick.RemoveListener(OnShowRoomRankingClicked);
|
||
}
|
||
|
||
if (sendMessageButton != null)
|
||
{
|
||
sendMessageButton.onClick.RemoveListener(OnSendMessageClicked);
|
||
}
|
||
|
||
if (songDropdown != null)
|
||
{
|
||
songDropdown.onValueChanged.RemoveListener(OnSongDropdownChanged);
|
||
}
|
||
|
||
if (difficultyDropdown != null)
|
||
{
|
||
difficultyDropdown.onValueChanged.RemoveListener(OnDifficultyDropdownChanged);
|
||
}
|
||
|
||
if (playerMessageInputField != null)
|
||
{
|
||
playerMessageInputField.onEndEdit.RemoveListener(OnChatInputEndEdit);
|
||
}
|
||
|
||
if (_countdownRoutine != null)
|
||
{
|
||
StopCoroutine(_countdownRoutine);
|
||
_countdownRoutine = null;
|
||
}
|
||
|
||
if (_messageScrollRect != null)
|
||
{
|
||
_messageScrollRect.onValueChanged.RemoveListener(OnChatScrollValueChanged);
|
||
}
|
||
|
||
if (_chatCooldownRoutine != null)
|
||
{
|
||
StopCoroutine(_chatCooldownRoutine);
|
||
_chatCooldownRoutine = null;
|
||
}
|
||
|
||
if (_messageLayoutRefreshCoroutine != null)
|
||
{
|
||
StopCoroutine(_messageLayoutRefreshCoroutine);
|
||
_messageLayoutRefreshCoroutine = null;
|
||
}
|
||
|
||
if (_refocusChatInputCoroutine != null)
|
||
{
|
||
StopCoroutine(_refocusChatInputCoroutine);
|
||
_refocusChatInputCoroutine = null;
|
||
}
|
||
|
||
if (_songLibraryWaitRoutine != null)
|
||
{
|
||
StopCoroutine(_songLibraryWaitRoutine);
|
||
_songLibraryWaitRoutine = null;
|
||
}
|
||
|
||
RestoreDefaultChatPlaceholder();
|
||
|
||
if (_spawnedRoomRankingInstance != null)
|
||
{
|
||
UIBackStack.Unregister(_spawnedRoomRankingInstance);
|
||
Destroy(_spawnedRoomRankingInstance);
|
||
_spawnedRoomRankingInstance = null;
|
||
}
|
||
}
|
||
|
||
private void HandleRoomSnapshotChanged(ArenaRoomSnapshot snapshot)
|
||
{
|
||
if (snapshot == null)
|
||
{
|
||
CloseSelfWithExitAnim();
|
||
return;
|
||
}
|
||
|
||
Refresh(snapshot);
|
||
}
|
||
|
||
private void HandleKicked(string kickedSteamId, string bySteamId)
|
||
{
|
||
CloseSelfWithExitAnim();
|
||
}
|
||
|
||
private void HandleRoomDismissed(string roomCode, string bySteamId)
|
||
{
|
||
CloseSelfWithExitAnim();
|
||
}
|
||
|
||
private void HandleRoomChatMessagesChanged(IReadOnlyList<ArenaRoomChatMessage> messages)
|
||
{
|
||
RenderChatMessages(messages, true);
|
||
}
|
||
|
||
private void HandleRoomSystemMessageReceived(string richText)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(richText))
|
||
{
|
||
return;
|
||
}
|
||
|
||
long createdAtUnixMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
|
||
string key = $"system:{createdAtUnixMs}:{richText}";
|
||
_systemFeedEntries.Add(new RoomSystemFeedEntry
|
||
{
|
||
richText = richText,
|
||
createdAtUnixMs = createdAtUnixMs,
|
||
sequence = GetOrAssignFeedSequence(key)
|
||
});
|
||
TrimSystemFeedCache();
|
||
RenderChatMessages(_service != null ? _service.GetRoomChatMessages() : null, true);
|
||
}
|
||
|
||
private async System.Threading.Tasks.Task InitializeRoomChatAsync()
|
||
{
|
||
if (_service == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
await _service.EnsureRoomChatSubscribed();
|
||
RenderChatMessages(_service.GetRoomChatMessages(), false);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"[roomDetails] Init room chat failed: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
private async void OnQuitClicked()
|
||
{
|
||
if (_service == null)
|
||
{
|
||
CloseSelfWithExitAnim();
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
string localSteamId = NetworkManager.Instance != null ? NetworkManager.Instance.SteamId : string.Empty;
|
||
bool localIsHost = IsLocalHost(_service.CurrentRoom, localSteamId);
|
||
if (localIsHost)
|
||
{
|
||
await _service.DismissRoom();
|
||
}
|
||
else
|
||
{
|
||
await _service.LeaveRoom();
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"[roomDetails] Leave room failed: {ex.Message}");
|
||
}
|
||
finally
|
||
{
|
||
CloseSelfWithExitAnim();
|
||
}
|
||
}
|
||
|
||
private void Refresh(ArenaRoomSnapshot snapshot)
|
||
{
|
||
if (snapshot == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (roomID != null)
|
||
{
|
||
roomID.text = snapshot.room_code;
|
||
}
|
||
|
||
if (thisSongName != null)
|
||
{
|
||
thisSongName.text = !string.IsNullOrWhiteSpace(snapshot.song_name)
|
||
? snapshot.song_name
|
||
: snapshot.song_id ?? string.Empty;
|
||
}
|
||
|
||
if (thisSongDifficulty != null)
|
||
{
|
||
thisSongDifficulty.text = FormatDifficulty(snapshot.difficulty);
|
||
}
|
||
|
||
if (_countdownRoutine != null)
|
||
{
|
||
StopCoroutine(_countdownRoutine);
|
||
}
|
||
|
||
_countdownRoutine = StartCoroutine(UpdateRemainTime(snapshot));
|
||
UpdateQuitButtonTexts(snapshot);
|
||
UpdateReadyButton(snapshot);
|
||
RenderParticipants(snapshot);
|
||
RefreshSongDropdowns(snapshot);
|
||
}
|
||
|
||
private IEnumerator UpdateRemainTime(ArenaRoomSnapshot snapshot)
|
||
{
|
||
while (snapshot != null && roomRemainTime != null)
|
||
{
|
||
long nowUnix = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
|
||
long remainSeconds = Math.Max(0L, snapshot.expires_at_unix - nowUnix);
|
||
int remainMinutes = Mathf.CeilToInt(remainSeconds / 60f);
|
||
roomRemainTime.text = $"{remainMinutes}分钟内不开始游戏将自动关闭房间";
|
||
|
||
yield return new WaitForSeconds(1f);
|
||
}
|
||
}
|
||
|
||
private void RenderParticipants(ArenaRoomSnapshot snapshot)
|
||
{
|
||
if (roommateParent == null || roommatePrefab == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
for (int i = roommateParent.childCount - 1; i >= 0; i--)
|
||
{
|
||
Destroy(roommateParent.GetChild(i).gameObject);
|
||
}
|
||
|
||
string localSteamId = _service != null && NetworkManager.Instance != null
|
||
? NetworkManager.Instance.SteamId
|
||
: string.Empty;
|
||
bool localIsHost = IsLocalHost(snapshot, localSteamId);
|
||
|
||
if (snapshot.participants == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
for (int i = 0; i < snapshot.participants.Count; i++)
|
||
{
|
||
ArenaRoomParticipant participant = snapshot.participants[i];
|
||
GameObject item = Instantiate(roommatePrefab, roommateParent);
|
||
UI_OrderedEntryAnimator.PlayFadeOnly(item, i, 0.16f, 0.012f, true);
|
||
roomPrefab itemController = item.GetComponent<roomPrefab>();
|
||
if (itemController == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
Sprite background = null;
|
||
if (participant != null && participant.is_host)
|
||
{
|
||
if (btmSprites != null && btmSprites.Length > 0)
|
||
{
|
||
background = btmSprites[0];
|
||
}
|
||
}
|
||
else if (btmSprites != null && btmSprites.Length > 1)
|
||
{
|
||
background = btmSprites[1];
|
||
}
|
||
|
||
itemController.Bind(participant, i + 1, localIsHost, localSteamId, background, HandleKickRequested);
|
||
}
|
||
}
|
||
|
||
private async void HandleKickRequested(string targetSteamId)
|
||
{
|
||
if (_service == null || string.IsNullOrWhiteSpace(targetSteamId))
|
||
{
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
await _service.KickPlayer(targetSteamId);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"[roomDetails] Kick failed: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
private async void OnReadyButtonClicked()
|
||
{
|
||
if (_service == null || _service.CurrentRoom == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
string localSteamId = NetworkManager.Instance != null ? NetworkManager.Instance.SteamId : string.Empty;
|
||
bool localIsHost = IsLocalHost(_service.CurrentRoom, localSteamId);
|
||
if (localIsHost)
|
||
{
|
||
if (CanHostStartGame(_service.CurrentRoom))
|
||
{
|
||
await _service.StartGame();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
await _service.ToggleReady();
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"[roomDetails] Ready/start failed: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
private async void OnSendMessageClicked()
|
||
{
|
||
if (_service == null || playerMessageInputField == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (Time.unscaledTime < _nextChatSendAllowedAt)
|
||
{
|
||
RefocusChatInputNextFrame();
|
||
UpdateChatSendUiState();
|
||
return;
|
||
}
|
||
|
||
string content = playerMessageInputField.text != null ? playerMessageInputField.text.Trim() : string.Empty;
|
||
if (string.IsNullOrWhiteSpace(content))
|
||
{
|
||
RefocusChatInputNextFrame();
|
||
return;
|
||
}
|
||
|
||
if (_isSendingRoomMessage && string.Equals(content, _pendingRoomMessageContent, StringComparison.Ordinal))
|
||
{
|
||
RefocusChatInputNextFrame();
|
||
return;
|
||
}
|
||
|
||
BeginChatCooldown();
|
||
_isSendingRoomMessage = true;
|
||
_pendingRoomMessageContent = content;
|
||
|
||
try
|
||
{
|
||
playerMessageInputField.text = string.Empty;
|
||
RefocusChatInputNextFrame();
|
||
await _service.SendRoomMessage(content);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
if (playerMessageInputField != null && string.IsNullOrEmpty(playerMessageInputField.text))
|
||
{
|
||
playerMessageInputField.text = content;
|
||
RefocusChatInputNextFrame();
|
||
}
|
||
|
||
Debug.LogWarning($"[roomDetails] Send room message failed: {ex.Message}");
|
||
}
|
||
finally
|
||
{
|
||
_isSendingRoomMessage = false;
|
||
_pendingRoomMessageContent = string.Empty;
|
||
}
|
||
}
|
||
|
||
private void OnChatInputEndEdit(string value)
|
||
{
|
||
if (!isActiveAndEnabled || playerMessageInputField == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (Input.GetKeyDown(KeyCode.Return) || Input.GetKeyDown(KeyCode.KeypadEnter))
|
||
{
|
||
OnSendMessageClicked();
|
||
}
|
||
}
|
||
|
||
private void BeginChatCooldown()
|
||
{
|
||
_nextChatSendAllowedAt = Time.unscaledTime + ChatSendCooldownSeconds;
|
||
if (_chatCooldownRoutine != null)
|
||
{
|
||
StopCoroutine(_chatCooldownRoutine);
|
||
}
|
||
|
||
_chatCooldownRoutine = StartCoroutine(ChatCooldownCoroutine());
|
||
UpdateChatSendUiState();
|
||
}
|
||
|
||
private IEnumerator ChatCooldownCoroutine()
|
||
{
|
||
while (Time.unscaledTime < _nextChatSendAllowedAt)
|
||
{
|
||
UpdateChatSendUiState();
|
||
yield return null;
|
||
}
|
||
|
||
_chatCooldownRoutine = null;
|
||
UpdateChatSendUiState();
|
||
}
|
||
|
||
private void UpdateChatSendUiState()
|
||
{
|
||
bool coolingDown = Time.unscaledTime < _nextChatSendAllowedAt;
|
||
if (sendMessageButton != null)
|
||
{
|
||
sendMessageButton.interactable = !coolingDown;
|
||
}
|
||
|
||
if (_chatPlaceholderText != null)
|
||
{
|
||
if (coolingDown)
|
||
{
|
||
float remain = Mathf.Max(0f, _nextChatSendAllowedAt - Time.unscaledTime);
|
||
_chatPlaceholderText.text = string.Format(CooldownPlaceholderFormat, Mathf.CeilToInt(remain));
|
||
}
|
||
else
|
||
{
|
||
_chatPlaceholderText.text = _defaultChatPlaceholder;
|
||
}
|
||
}
|
||
}
|
||
|
||
private void RestoreDefaultChatPlaceholder()
|
||
{
|
||
if (_chatPlaceholderText != null)
|
||
{
|
||
_chatPlaceholderText.text = _defaultChatPlaceholder;
|
||
}
|
||
}
|
||
|
||
private void RenderChatMessages(IReadOnlyList<ArenaRoomChatMessage> messages, bool preserveWindow)
|
||
{
|
||
if (messageParent == null || messages == null || playerMessagePrefab == null)
|
||
{
|
||
ClearDisplayedMessages();
|
||
return;
|
||
}
|
||
|
||
List<RoomFeedEntry> feed = BuildRoomFeed(messages);
|
||
UpdateChatWindowState(feed.Count, preserveWindow);
|
||
|
||
int startIndex = Mathf.Clamp(_chatWindowStartIndex, 0, Mathf.Max(0, feed.Count - 1));
|
||
int endIndex = Mathf.Min(feed.Count, startIndex + GetRenderedChatWindowCapacity());
|
||
var visibleEntries = new List<RoomFeedEntry>(Mathf.Max(0, endIndex - startIndex));
|
||
for (int i = startIndex; i < endIndex; i++)
|
||
{
|
||
visibleEntries.Add(feed[i]);
|
||
}
|
||
|
||
bool changed = ApplyRenderedChatEntries(visibleEntries);
|
||
if (changed)
|
||
{
|
||
ScheduleMessageLayoutRefresh(_isChatViewPinnedToBottom);
|
||
}
|
||
}
|
||
|
||
private bool ApplyRenderedChatEntries(List<RoomFeedEntry> visibleEntries)
|
||
{
|
||
var desiredKeys = new List<string>(visibleEntries.Count);
|
||
for (int i = 0; i < visibleEntries.Count; i++)
|
||
{
|
||
desiredKeys.Add(visibleEntries[i].key);
|
||
}
|
||
|
||
if (desiredKeys.Count == _renderedChatKeys.Count)
|
||
{
|
||
bool identical = true;
|
||
for (int i = 0; i < desiredKeys.Count; i++)
|
||
{
|
||
if (!string.Equals(desiredKeys[i], _renderedChatKeys[i], StringComparison.Ordinal))
|
||
{
|
||
identical = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (identical)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
int prefix = 0;
|
||
int sharedCount = Mathf.Min(_renderedChatKeys.Count, desiredKeys.Count);
|
||
while (prefix < sharedCount && string.Equals(_renderedChatKeys[prefix], desiredKeys[prefix], StringComparison.Ordinal))
|
||
{
|
||
prefix++;
|
||
}
|
||
|
||
int suffix = 0;
|
||
while (suffix < (_renderedChatKeys.Count - prefix)
|
||
&& suffix < (desiredKeys.Count - prefix)
|
||
&& string.Equals(
|
||
_renderedChatKeys[_renderedChatKeys.Count - 1 - suffix],
|
||
desiredKeys[desiredKeys.Count - 1 - suffix],
|
||
StringComparison.Ordinal))
|
||
{
|
||
suffix++;
|
||
}
|
||
|
||
for (int i = _renderedChatObjects.Count - suffix - 1; i >= prefix; i--)
|
||
{
|
||
GameObject instance = _renderedChatObjects[i];
|
||
if (instance != null)
|
||
{
|
||
Destroy(instance);
|
||
}
|
||
|
||
_renderedChatObjects.RemoveAt(i);
|
||
_renderedChatKeys.RemoveAt(i);
|
||
}
|
||
|
||
for (int i = prefix; i < desiredKeys.Count - suffix; i++)
|
||
{
|
||
GameObject instance = CreateChatFeedObject(visibleEntries[i]);
|
||
_renderedChatObjects.Insert(i, instance);
|
||
_renderedChatKeys.Insert(i, desiredKeys[i]);
|
||
RegisterMessageLayoutDirtyRoot(instance);
|
||
}
|
||
|
||
for (int i = 0; i < _renderedChatObjects.Count; i++)
|
||
{
|
||
if (_renderedChatObjects[i] != null)
|
||
{
|
||
_renderedChatObjects[i].transform.SetSiblingIndex(i);
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private GameObject CreateChatFeedObject(RoomFeedEntry feedEntry)
|
||
{
|
||
object entry = feedEntry.entry;
|
||
if (entry is RoomSystemFeedEntry systemEntry)
|
||
{
|
||
if (systemMessagePrefab == null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
GameObject systemInstance = Instantiate(systemMessagePrefab, messageParent, false);
|
||
systemMessagePrefab systemController = systemInstance.GetComponent<systemMessagePrefab>();
|
||
if (systemController != null)
|
||
{
|
||
systemController.Bind(systemEntry.richText);
|
||
}
|
||
|
||
UI_OrderedEntryAnimator.PlayFadeOnly(systemInstance, Mathf.Max(0, messageParent.childCount - 1), 0.14f, 0.01f, true);
|
||
return systemInstance;
|
||
}
|
||
|
||
ArenaRoomChatMessage message = entry as ArenaRoomChatMessage;
|
||
if (message == null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
string localSteamId = NetworkManager.Instance != null ? NetworkManager.Instance.SteamId : string.Empty;
|
||
string senderSteamId = GetMessageSenderSteamId(message);
|
||
bool isSelf = !string.IsNullOrWhiteSpace(localSteamId)
|
||
&& string.Equals(senderSteamId, localSteamId, StringComparison.Ordinal);
|
||
Color bubbleColor = ResolveMessageBubbleColor(isSelf);
|
||
string displayName = ResolveMessageDisplayName(message, isSelf);
|
||
string title = ResolveMessageTitle(message);
|
||
|
||
GameObject instance = Instantiate(playerMessagePrefab, messageParent, false);
|
||
playerMessagePrefab controller = instance.GetComponent<playerMessagePrefab>();
|
||
if (controller != null)
|
||
{
|
||
string avatarUrl = GameServer.Client.NetworkManager.ResolveAvatarUrl(message.avatar_url, senderSteamId);
|
||
string titleId = message != null && !string.IsNullOrWhiteSpace(message.player_title_id)
|
||
? message.player_title_id
|
||
: string.Empty;
|
||
PlayerTitleResolver.ResolvedTitle resolvedTitle = PlayerTitleResolver.Resolve(titleId, title);
|
||
controller.Bind(senderSteamId, avatarUrl, displayName, resolvedTitle.titleId, resolvedTitle.titleText, message.content, bubbleColor);
|
||
}
|
||
|
||
UI_OrderedEntryAnimator.PlayFadeOnly(instance, Mathf.Max(0, messageParent.childCount - 1), 0.14f, 0.01f, true);
|
||
return instance;
|
||
}
|
||
|
||
private static string BuildRoomSystemKey(RoomSystemFeedEntry entry)
|
||
{
|
||
return $"system:{entry.createdAtUnixMs}:{entry.richText}";
|
||
}
|
||
|
||
private static string BuildRoomMessageKey(ArenaRoomChatMessage message)
|
||
{
|
||
if (message == null)
|
||
{
|
||
return "message:null";
|
||
}
|
||
|
||
if (message.id > 0)
|
||
{
|
||
return $"message:id:{message.id}";
|
||
}
|
||
|
||
string sender = GetMessageSenderSteamId(message);
|
||
return $"message:fallback:{message.room_code}:{sender}:{message.created_at}:{message.content}";
|
||
}
|
||
|
||
private void TrimSystemFeedCache()
|
||
|
||
{
|
||
int overflow = _systemFeedEntries.Count - GetEffectiveCacheLimit();
|
||
if (overflow > 0)
|
||
{
|
||
_systemFeedEntries.RemoveRange(0, overflow);
|
||
}
|
||
}
|
||
|
||
private List<RoomFeedEntry> BuildRoomFeed(IReadOnlyList<ArenaRoomChatMessage> messages)
|
||
{
|
||
List<RoomFeedEntry> feed = new List<RoomFeedEntry>();
|
||
int order = 0;
|
||
int startIndex = Mathf.Max(0, messages.Count - GetEffectiveCacheLimit());
|
||
for (int i = startIndex; i < messages.Count; i++)
|
||
{
|
||
ArenaRoomChatMessage message = messages[i];
|
||
if (message != null)
|
||
{
|
||
string key = BuildRoomMessageKey(message);
|
||
feed.Add(new RoomFeedEntry
|
||
{
|
||
entry = message,
|
||
timestampMs = ParseMessageUnixTimestamp(message.created_at),
|
||
order = order++,
|
||
key = key,
|
||
sequence = GetOrAssignFeedSequence(key)
|
||
});
|
||
}
|
||
}
|
||
|
||
for (int i = 0; i < _systemFeedEntries.Count; i++)
|
||
{
|
||
RoomSystemFeedEntry systemEntry = _systemFeedEntries[i];
|
||
if (systemEntry == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
feed.Add(new RoomFeedEntry
|
||
{
|
||
entry = systemEntry,
|
||
timestampMs = systemEntry.createdAtUnixMs,
|
||
order = order++,
|
||
key = BuildRoomSystemKey(systemEntry),
|
||
sequence = systemEntry.sequence
|
||
});
|
||
}
|
||
|
||
feed.Sort(CompareFeedEntries);
|
||
return feed;
|
||
}
|
||
|
||
private void UpdateChatWindowState(int feedCount, bool preserveWindow)
|
||
{
|
||
int windowCapacity = GetRenderedChatWindowCapacity();
|
||
int maxStart = Mathf.Max(0, feedCount - windowCapacity);
|
||
if (!preserveWindow || _chatWindowStartIndex < 0 || _isChatViewPinnedToBottom)
|
||
{
|
||
_chatWindowStartIndex = maxStart;
|
||
_isChatViewPinnedToBottom = true;
|
||
return;
|
||
}
|
||
|
||
_chatWindowStartIndex = Mathf.Clamp(_chatWindowStartIndex, 0, maxStart);
|
||
}
|
||
|
||
private void OnChatScrollValueChanged(Vector2 normalizedPosition)
|
||
{
|
||
if (_suppressChatScrollEvents || _service == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
List<RoomFeedEntry> feed = BuildRoomFeed(_service.GetRoomChatMessages());
|
||
if (feed.Count <= GetRenderedChatWindowCapacity())
|
||
{
|
||
_isChatViewPinnedToBottom = true;
|
||
return;
|
||
}
|
||
|
||
if (normalizedPosition.y <= 0.05f)
|
||
{
|
||
int maxStart = Mathf.Max(0, feed.Count - GetRenderedChatWindowCapacity());
|
||
if (_chatWindowStartIndex < maxStart)
|
||
{
|
||
_chatWindowStartIndex = Mathf.Min(maxStart, _chatWindowStartIndex + GetEffectiveDisplayWindow());
|
||
_isChatViewPinnedToBottom = _chatWindowStartIndex >= maxStart;
|
||
RenderChatMessages(_service.GetRoomChatMessages(), true);
|
||
SetChatScrollNormalizedPosition(0.15f);
|
||
return;
|
||
}
|
||
|
||
_isChatViewPinnedToBottom = true;
|
||
}
|
||
else if (normalizedPosition.y >= 0.95f && _chatWindowStartIndex > 0)
|
||
{
|
||
_chatWindowStartIndex = Mathf.Max(0, _chatWindowStartIndex - GetEffectiveDisplayWindow());
|
||
_isChatViewPinnedToBottom = false;
|
||
RenderChatMessages(_service.GetRoomChatMessages(), true);
|
||
SetChatScrollNormalizedPosition(0.85f);
|
||
}
|
||
else
|
||
{
|
||
_isChatViewPinnedToBottom = false;
|
||
}
|
||
}
|
||
|
||
private static int CompareFeedEntries(RoomFeedEntry left, RoomFeedEntry right)
|
||
{
|
||
int compare = left.sequence.CompareTo(right.sequence);
|
||
if (compare != 0)
|
||
{
|
||
return compare;
|
||
}
|
||
|
||
compare = left.timestampMs.CompareTo(right.timestampMs);
|
||
if (compare != 0)
|
||
{
|
||
return compare;
|
||
}
|
||
|
||
return left.order.CompareTo(right.order);
|
||
}
|
||
|
||
private long GetOrAssignFeedSequence(string key)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(key))
|
||
{
|
||
return _nextFeedSequence++;
|
||
}
|
||
|
||
if (_feedSequences.TryGetValue(key, out long sequence))
|
||
{
|
||
return sequence;
|
||
}
|
||
|
||
sequence = _nextFeedSequence++;
|
||
_feedSequences[key] = sequence;
|
||
return sequence;
|
||
}
|
||
|
||
private static long ParseMessageUnixTimestamp(string createdAt)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(createdAt))
|
||
{
|
||
return long.MaxValue;
|
||
}
|
||
|
||
if (long.TryParse(createdAt, out long unixValue))
|
||
{
|
||
return unixValue >= 1_000_000_000_000L ? unixValue : unixValue * 1000L;
|
||
}
|
||
|
||
if (DateTimeOffset.TryParse(createdAt, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out DateTimeOffset parsed))
|
||
{
|
||
return parsed.ToUnixTimeMilliseconds();
|
||
}
|
||
|
||
return long.MaxValue;
|
||
}
|
||
|
||
private void ClearDisplayedMessages()
|
||
{
|
||
if (messageParent == null)
|
||
{
|
||
_renderedChatKeys.Clear();
|
||
_renderedChatObjects.Clear();
|
||
return;
|
||
}
|
||
|
||
for (int i = messageParent.childCount - 1; i >= 0; i--)
|
||
{
|
||
Transform child = messageParent.GetChild(i);
|
||
child.SetParent(null, false);
|
||
child.gameObject.SetActive(false);
|
||
Destroy(child.gameObject);
|
||
}
|
||
|
||
_renderedChatKeys.Clear();
|
||
_renderedChatObjects.Clear();
|
||
}
|
||
|
||
private Color ResolveMessageBubbleColor(bool isSelf)
|
||
{
|
||
if (messageTypeColors == null || messageTypeColors.Length == 0)
|
||
{
|
||
return Color.white;
|
||
}
|
||
|
||
if (isSelf && messageTypeColors.Length > 1)
|
||
{
|
||
return messageTypeColors[1];
|
||
}
|
||
|
||
return messageTypeColors[0];
|
||
}
|
||
|
||
private string ResolveMessageDisplayName(ArenaRoomChatMessage message, bool isSelf)
|
||
{
|
||
if (message != null && !string.IsNullOrWhiteSpace(message.display_name))
|
||
{
|
||
string senderSteamId = GetMessageSenderSteamId(message);
|
||
if (GameServer.Client.NetworkManager.IsUsableDisplayName(message.display_name, senderSteamId))
|
||
{
|
||
return message.display_name;
|
||
}
|
||
}
|
||
|
||
string messageSteamId = GetMessageSenderSteamId(message);
|
||
if (isSelf && NetworkManager.Instance != null && GameServer.Client.NetworkManager.IsUsableDisplayName(NetworkManager.Instance.SteamDisplayName, messageSteamId))
|
||
{
|
||
return NetworkManager.Instance.SteamDisplayName;
|
||
}
|
||
|
||
if (_service != null && _service.CurrentRoom != null && _service.CurrentRoom.participants != null && message != null)
|
||
{
|
||
foreach (ArenaRoomParticipant participant in _service.CurrentRoom.participants)
|
||
{
|
||
if (participant != null
|
||
&& string.Equals(participant.steam_id, messageSteamId, StringComparison.Ordinal)
|
||
&& GameServer.Client.NetworkManager.IsUsableDisplayName(participant.display_name, messageSteamId))
|
||
{
|
||
return participant.display_name;
|
||
}
|
||
}
|
||
}
|
||
|
||
return GameServer.Client.NetworkManager.ResolveDisplayName(message != null ? message.display_name : string.Empty, messageSteamId, false);
|
||
}
|
||
|
||
private static string ResolveMessageTitle(ArenaRoomChatMessage message)
|
||
{
|
||
return message != null && !string.IsNullOrWhiteSpace(message.player_title)
|
||
? message.player_title
|
||
: string.Empty;
|
||
}
|
||
|
||
private static string GetMessageSenderSteamId(ArenaRoomChatMessage message)
|
||
{
|
||
if (message == null)
|
||
{
|
||
return string.Empty;
|
||
}
|
||
|
||
if (!string.IsNullOrWhiteSpace(message.sender_id))
|
||
{
|
||
return message.sender_id;
|
||
}
|
||
|
||
return message.steam_id ?? string.Empty;
|
||
}
|
||
|
||
private void ScheduleMessageLayoutRefresh(bool scrollToBottom)
|
||
{
|
||
_messageLayoutRefreshDirty = true;
|
||
_scrollChatToBottomAfterLayout |= scrollToBottom;
|
||
if (_messageLayoutRefreshCoroutine == null)
|
||
{
|
||
_messageLayoutRefreshCoroutine = StartCoroutine(DeferredMessageLayoutRefreshCoroutine());
|
||
}
|
||
}
|
||
|
||
private IEnumerator DeferredMessageLayoutRefreshCoroutine()
|
||
{
|
||
while (true)
|
||
{
|
||
yield return null;
|
||
|
||
bool shouldRebuild = _messageLayoutRefreshDirty;
|
||
bool shouldScrollToBottom = _scrollChatToBottomAfterLayout;
|
||
_messageLayoutRefreshDirty = false;
|
||
_scrollChatToBottomAfterLayout = false;
|
||
|
||
if (shouldRebuild)
|
||
{
|
||
ForceRebuildMessageLayoutImmediate();
|
||
if (shouldScrollToBottom && _messageScrollRect != null)
|
||
{
|
||
Canvas.ForceUpdateCanvases();
|
||
_messageScrollRect.verticalNormalizedPosition = 0f;
|
||
}
|
||
}
|
||
|
||
if (!_messageLayoutRefreshDirty)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
_messageLayoutRefreshCoroutine = null;
|
||
}
|
||
|
||
private void ForceRebuildMessageLayoutImmediate()
|
||
{
|
||
if (!(messageParent is RectTransform messageParentRect))
|
||
{
|
||
return;
|
||
}
|
||
|
||
for (int i = 0; i < _pendingMessageLayoutDirtyRoots.Count; i++)
|
||
{
|
||
RectTransform childRect = _pendingMessageLayoutDirtyRoots[i];
|
||
if (childRect != null)
|
||
{
|
||
LayoutRebuilder.ForceRebuildLayoutImmediate(childRect);
|
||
}
|
||
}
|
||
_pendingMessageLayoutDirtyRoots.Clear();
|
||
|
||
LayoutRebuilder.ForceRebuildLayoutImmediate(messageParentRect);
|
||
if (messageParentRect.parent is RectTransform parentRect)
|
||
{
|
||
LayoutRebuilder.ForceRebuildLayoutImmediate(parentRect);
|
||
}
|
||
Canvas.ForceUpdateCanvases();
|
||
}
|
||
|
||
private void RefocusChatInputNextFrame()
|
||
{
|
||
if (playerMessageInputField == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
_refocusChatInputRequested = true;
|
||
if (_refocusChatInputCoroutine == null)
|
||
{
|
||
_refocusChatInputCoroutine = StartCoroutine(RefocusChatInputCoroutine());
|
||
}
|
||
}
|
||
|
||
private IEnumerator RefocusChatInputCoroutine()
|
||
{
|
||
while (true)
|
||
{
|
||
yield return null;
|
||
if (!_refocusChatInputRequested)
|
||
{
|
||
break;
|
||
}
|
||
|
||
_refocusChatInputRequested = false;
|
||
if (playerMessageInputField == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
EventSystem.current?.SetSelectedGameObject(playerMessageInputField.gameObject);
|
||
playerMessageInputField.Select();
|
||
playerMessageInputField.ActivateInputField();
|
||
playerMessageInputField.MoveTextEnd(false);
|
||
}
|
||
|
||
_refocusChatInputCoroutine = null;
|
||
}
|
||
|
||
private void SetChatScrollNormalizedPosition(float value)
|
||
{
|
||
if (_messageScrollRect == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
_suppressChatScrollEvents = true;
|
||
_messageScrollRect.verticalNormalizedPosition = Mathf.Clamp01(value);
|
||
_suppressChatScrollEvents = false;
|
||
}
|
||
|
||
private void RegisterMessageLayoutDirtyRoot(GameObject instance)
|
||
{
|
||
if (instance == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
RectTransform rect = instance.transform as RectTransform;
|
||
if (rect == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
for (int i = 0; i < _pendingMessageLayoutDirtyRoots.Count; i++)
|
||
{
|
||
if (_pendingMessageLayoutDirtyRoots[i] == rect)
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
|
||
_pendingMessageLayoutDirtyRoots.Add(rect);
|
||
}
|
||
|
||
private void OnShowRoomRankingClicked()
|
||
{
|
||
if (_service == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
GameObject template = _roomRankingPrefabTemplate;
|
||
Transform parent = _roomRankingSpawnParent != null ? _roomRankingSpawnParent : transform.parent;
|
||
if (template == null || parent == null)
|
||
{
|
||
Debug.LogWarning("[roomDetails] Room ranking prefab or parent is missing.");
|
||
return;
|
||
}
|
||
|
||
if (_spawnedRoomRankingInstance == null)
|
||
{
|
||
_spawnedRoomRankingInstance = Instantiate(template, parent, false);
|
||
RectTransform rect = _spawnedRoomRankingInstance.GetComponent<RectTransform>();
|
||
if (rect != null)
|
||
{
|
||
rect.localScale = Vector3.one;
|
||
rect.anchoredPosition3D = Vector3.zero;
|
||
}
|
||
}
|
||
|
||
UIBackStack.RegisterOrBump(
|
||
_spawnedRoomRankingInstance,
|
||
() => _spawnedRoomRankingInstance != null && _spawnedRoomRankingInstance.activeInHierarchy,
|
||
() =>
|
||
{
|
||
if (_spawnedRoomRankingInstance != null)
|
||
{
|
||
CloseRoomRankingWithExitAnim();
|
||
}
|
||
|
||
return true;
|
||
});
|
||
|
||
rankingListPrefab ranking = _spawnedRoomRankingInstance.GetComponent<rankingListPrefab>();
|
||
if (ranking == null)
|
||
{
|
||
Debug.LogWarning("[roomDetails] Room ranking prefab is missing rankingListPrefab component.");
|
||
return;
|
||
}
|
||
|
||
ArenaRoomSnapshot snapshot = _service.CurrentRoom;
|
||
LeaderboardData roomRanking = _service.GetRoomRankingLeaderboardData();
|
||
string localSteamId = NetworkManager.Instance != null ? NetworkManager.Instance.SteamId : string.Empty;
|
||
ranking.BindRoomRanking(
|
||
snapshot != null ? snapshot.song_id : string.Empty,
|
||
snapshot != null ? snapshot.song_name : string.Empty,
|
||
roomRanking,
|
||
localSteamId);
|
||
}
|
||
|
||
private void CloseSelfWithExitAnim()
|
||
{
|
||
if (_isClosingSelf)
|
||
{
|
||
return;
|
||
}
|
||
|
||
_isClosingSelf = true;
|
||
UI_PanelExitUtility.PlayExitThen(gameObject, () =>
|
||
{
|
||
if (gameObject != null)
|
||
{
|
||
Destroy(gameObject);
|
||
}
|
||
});
|
||
}
|
||
|
||
private void CloseRoomRankingWithExitAnim()
|
||
{
|
||
GameObject rankingInstance = _spawnedRoomRankingInstance;
|
||
if (rankingInstance == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
UIBackStack.Unregister(rankingInstance);
|
||
_spawnedRoomRankingInstance = null;
|
||
UI_PanelExitUtility.PlayExitThen(rankingInstance, () =>
|
||
{
|
||
if (rankingInstance != null)
|
||
{
|
||
Destroy(rankingInstance);
|
||
}
|
||
});
|
||
}
|
||
|
||
private void EnsurePopupTween()
|
||
{
|
||
if (GetComponent<UI_PanelPopupTween>() == null)
|
||
{
|
||
gameObject.AddComponent<UI_PanelPopupTween>();
|
||
}
|
||
}
|
||
|
||
private void UpdateQuitButtonTexts(ArenaRoomSnapshot snapshot)
|
||
{
|
||
string localSteamId = NetworkManager.Instance != null ? NetworkManager.Instance.SteamId : string.Empty;
|
||
bool localIsHost = IsLocalHost(snapshot, localSteamId);
|
||
string buttonText = localIsHost ? "解散房间" : "退出房间";
|
||
|
||
SetButtonText(quitRoom, buttonText);
|
||
SetButtonText(quitRoom2, buttonText);
|
||
}
|
||
|
||
private void UpdateReadyButton(ArenaRoomSnapshot snapshot)
|
||
{
|
||
if (getReady == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
string localSteamId = NetworkManager.Instance != null ? NetworkManager.Instance.SteamId : string.Empty;
|
||
bool localIsHost = IsLocalHost(snapshot, localSteamId);
|
||
int readyCount = CountReadyPlayers(snapshot);
|
||
int totalCount = snapshot != null
|
||
? Mathf.Max(snapshot.player_count, snapshot.participants != null ? snapshot.participants.Count : 0)
|
||
: 0;
|
||
bool roomStarted = IsRoomStarted(snapshot);
|
||
|
||
string buttonText;
|
||
bool interactable;
|
||
|
||
if (localIsHost)
|
||
{
|
||
buttonText = $"开始游戏（{readyCount}/{totalCount}）";
|
||
interactable = !roomStarted && CanHostStartGame(snapshot);
|
||
}
|
||
else
|
||
{
|
||
bool localReady = IsLocalReady(snapshot, localSteamId);
|
||
buttonText = localReady ? "取消准备" : "准备";
|
||
interactable = !roomStarted;
|
||
}
|
||
|
||
getReady.interactable = interactable;
|
||
SetButtonText(getReady, buttonText);
|
||
}
|
||
|
||
private static bool IsLocalHost(ArenaRoomSnapshot snapshot, string localSteamId)
|
||
{
|
||
if (snapshot == null || string.IsNullOrWhiteSpace(localSteamId))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (string.Equals(snapshot.host_steam_id, localSteamId, StringComparison.Ordinal))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (snapshot.participants == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
foreach (ArenaRoomParticipant participant in snapshot.participants)
|
||
{
|
||
if (participant != null
|
||
&& string.Equals(participant.steam_id, localSteamId, StringComparison.Ordinal)
|
||
&& participant.is_host)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
private static bool IsLocalReady(ArenaRoomSnapshot snapshot, string localSteamId)
|
||
{
|
||
if (snapshot == null || snapshot.participants == null || string.IsNullOrWhiteSpace(localSteamId))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
foreach (ArenaRoomParticipant participant in snapshot.participants)
|
||
{
|
||
if (participant != null && string.Equals(participant.steam_id, localSteamId, StringComparison.Ordinal))
|
||
{
|
||
return participant.is_ready;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
private static int CountReadyPlayers(ArenaRoomSnapshot snapshot)
|
||
{
|
||
if (snapshot == null || snapshot.participants == null)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int count = 0;
|
||
foreach (ArenaRoomParticipant participant in snapshot.participants)
|
||
{
|
||
if (participant != null && participant.is_ready)
|
||
{
|
||
count++;
|
||
}
|
||
}
|
||
return count;
|
||
}
|
||
|
||
private static bool CanHostStartGame(ArenaRoomSnapshot snapshot)
|
||
{
|
||
if (snapshot == null || snapshot.participants == null || snapshot.participants.Count < 2)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
foreach (ArenaRoomParticipant participant in snapshot.participants)
|
||
{
|
||
if (participant == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!participant.is_host && !participant.is_ready)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private static bool IsRoomStarted(ArenaRoomSnapshot snapshot)
|
||
{
|
||
if (snapshot == null || string.IsNullOrWhiteSpace(snapshot.status))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return string.Equals(snapshot.status, "STARTED", StringComparison.OrdinalIgnoreCase)
|
||
|| string.Equals(snapshot.status, "PLAYING", StringComparison.OrdinalIgnoreCase);
|
||
}
|
||
|
||
private void EnsureSongDropdownsReady()
|
||
{
|
||
if (songDropdown == null && difficultyDropdown == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
SongDataLibrary library = SongDataLibrary.Instance;
|
||
if (library != null && library.IsLoaded)
|
||
{
|
||
RefreshSongDropdowns(_service != null ? _service.CurrentRoom : null);
|
||
return;
|
||
}
|
||
|
||
if (_songLibraryWaitRoutine == null)
|
||
{
|
||
_songLibraryWaitRoutine = StartCoroutine(WaitForSongLibraryAndRefresh());
|
||
}
|
||
}
|
||
|
||
private IEnumerator WaitForSongLibraryAndRefresh()
|
||
{
|
||
float timeoutAt = Time.realtimeSinceStartup + 8f;
|
||
while (Time.realtimeSinceStartup < timeoutAt)
|
||
{
|
||
SongDataLibrary library = SongDataLibrary.Instance;
|
||
if (library != null && library.IsLoaded)
|
||
{
|
||
_songLibraryWaitRoutine = null;
|
||
RefreshSongDropdowns(_service != null ? _service.CurrentRoom : null);
|
||
yield break;
|
||
}
|
||
|
||
yield return null;
|
||
}
|
||
|
||
_songLibraryWaitRoutine = null;
|
||
Debug.LogWarning("[roomDetails] SongDataLibrary was not ready; song dropdowns were left empty.");
|
||
}
|
||
|
||
private void RefreshSongDropdowns(ArenaRoomSnapshot snapshot)
|
||
{
|
||
if (songDropdown == null && difficultyDropdown == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
SongDataLibrary library = SongDataLibrary.Instance;
|
||
if (library == null || !library.IsLoaded)
|
||
{
|
||
EnsureSongDropdownsReady();
|
||
UpdateSongDropdownInteractable(snapshot);
|
||
return;
|
||
}
|
||
|
||
RebuildSelectableSongs(library);
|
||
SongData selectedSong = ResolveSnapshotSong(snapshot);
|
||
if (selectedSong == null && _selectableSongs.Count > 0)
|
||
{
|
||
selectedSong = _selectableSongs[0];
|
||
}
|
||
|
||
int selectedDifficulty = ConvertDifficultyKeyToId(snapshot != null ? snapshot.difficulty : null);
|
||
if (selectedSong != null)
|
||
{
|
||
RebuildSelectableDifficulties(selectedSong);
|
||
if (!_selectableDifficulties.Contains(selectedDifficulty))
|
||
{
|
||
selectedDifficulty = _selectableDifficulties.Count > 0 ? _selectableDifficulties[0] : selectedDifficulty;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_selectableDifficulties.Clear();
|
||
}
|
||
|
||
_suppressSongDropdownEvents = true;
|
||
try
|
||
{
|
||
PopulateSongDropdown(selectedSong);
|
||
PopulateDifficultyDropdown(selectedSong, selectedDifficulty);
|
||
}
|
||
finally
|
||
{
|
||
_suppressSongDropdownEvents = false;
|
||
}
|
||
|
||
UpdateSongDropdownInteractable(snapshot);
|
||
}
|
||
|
||
private void RebuildSelectableSongs(SongDataLibrary library)
|
||
{
|
||
_selectableSongs.Clear();
|
||
|
||
List<SongData> songs = library != null ? library.GetAllSongs() : null;
|
||
if (songs == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
songs.Sort((left, right) =>
|
||
{
|
||
int idCompare = (left != null ? left.songID : int.MaxValue).CompareTo(right != null ? right.songID : int.MaxValue);
|
||
if (idCompare != 0)
|
||
{
|
||
return idCompare;
|
||
}
|
||
|
||
return string.Compare(left != null ? left.songName : string.Empty,
|
||
right != null ? right.songName : string.Empty,
|
||
StringComparison.CurrentCulture);
|
||
});
|
||
|
||
foreach (SongData song in songs)
|
||
{
|
||
if (song != null && HasPlayableDifficulty(song))
|
||
{
|
||
_selectableSongs.Add(song);
|
||
}
|
||
}
|
||
}
|
||
|
||
private SongData ResolveSnapshotSong(ArenaRoomSnapshot snapshot)
|
||
{
|
||
if (snapshot != null && int.TryParse(snapshot.song_id, out int songId))
|
||
{
|
||
for (int i = 0; i < _selectableSongs.Count; i++)
|
||
{
|
||
SongData song = _selectableSongs[i];
|
||
if (song != null && song.songID == songId)
|
||
{
|
||
return song;
|
||
}
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
private void RebuildSelectableDifficulties(SongData song)
|
||
{
|
||
_selectableDifficulties.Clear();
|
||
if (song == null || song.chartFiles == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
foreach (ChartFileEntry entry in song.chartFiles)
|
||
{
|
||
if (entry == null || entry.chartFile == null || _selectableDifficulties.Contains(entry.difficulty))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
_selectableDifficulties.Add(entry.difficulty);
|
||
}
|
||
|
||
_selectableDifficulties.Sort();
|
||
}
|
||
|
||
private void PopulateSongDropdown(SongData selectedSong)
|
||
{
|
||
if (songDropdown == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
songDropdown.ClearOptions();
|
||
List<string> options = new List<string>();
|
||
for (int i = 0; i < _selectableSongs.Count; i++)
|
||
{
|
||
SongData song = _selectableSongs[i];
|
||
options.Add(song != null && !string.IsNullOrWhiteSpace(song.songName) ? song.songName : $"Song {song?.songID ?? 0}");
|
||
}
|
||
|
||
songDropdown.AddOptions(options);
|
||
int selectedIndex = selectedSong != null ? _selectableSongs.IndexOf(selectedSong) : -1;
|
||
songDropdown.value = Mathf.Clamp(selectedIndex, 0, Mathf.Max(0, _selectableSongs.Count - 1));
|
||
songDropdown.RefreshShownValue();
|
||
}
|
||
|
||
private void PopulateDifficultyDropdown(SongData selectedSong, int selectedDifficulty)
|
||
{
|
||
if (difficultyDropdown == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
difficultyDropdown.ClearOptions();
|
||
List<string> options = new List<string>();
|
||
for (int i = 0; i < _selectableDifficulties.Count; i++)
|
||
{
|
||
options.Add(FormatDifficultyOption(selectedSong, _selectableDifficulties[i]));
|
||
}
|
||
|
||
difficultyDropdown.AddOptions(options);
|
||
int selectedIndex = _selectableDifficulties.IndexOf(selectedDifficulty);
|
||
difficultyDropdown.value = Mathf.Clamp(selectedIndex, 0, Mathf.Max(0, _selectableDifficulties.Count - 1));
|
||
difficultyDropdown.RefreshShownValue();
|
||
}
|
||
|
||
private void UpdateSongDropdownInteractable(ArenaRoomSnapshot snapshot)
|
||
{
|
||
string localSteamId = NetworkManager.Instance != null ? NetworkManager.Instance.SteamId : string.Empty;
|
||
bool canChange = !_isChangingRoomSong
|
||
&& snapshot != null
|
||
&& IsLocalHost(snapshot, localSteamId)
|
||
&& !IsRoomStarted(snapshot)
|
||
&& _selectableSongs.Count > 0;
|
||
|
||
if (songDropdown != null)
|
||
{
|
||
songDropdown.interactable = canChange;
|
||
}
|
||
|
||
if (difficultyDropdown != null)
|
||
{
|
||
difficultyDropdown.interactable = canChange && _selectableDifficulties.Count > 0;
|
||
}
|
||
}
|
||
|
||
private void OnSongDropdownChanged(int index)
|
||
{
|
||
if (_suppressSongDropdownEvents || index < 0 || index >= _selectableSongs.Count)
|
||
{
|
||
return;
|
||
}
|
||
|
||
SongData song = _selectableSongs[index];
|
||
int currentDifficulty = GetSelectedDifficultyId();
|
||
RebuildSelectableDifficulties(song);
|
||
if (!_selectableDifficulties.Contains(currentDifficulty))
|
||
{
|
||
currentDifficulty = _selectableDifficulties.Count > 0 ? _selectableDifficulties[0] : 2;
|
||
}
|
||
|
||
_suppressSongDropdownEvents = true;
|
||
try
|
||
{
|
||
PopulateDifficultyDropdown(song, currentDifficulty);
|
||
}
|
||
finally
|
||
{
|
||
_suppressSongDropdownEvents = false;
|
||
}
|
||
|
||
RequestChangeRoomSong(song, currentDifficulty);
|
||
}
|
||
|
||
private void OnDifficultyDropdownChanged(int index)
|
||
{
|
||
if (_suppressSongDropdownEvents || index < 0 || index >= _selectableDifficulties.Count)
|
||
{
|
||
return;
|
||
}
|
||
|
||
SongData song = GetSelectedSong();
|
||
RequestChangeRoomSong(song, _selectableDifficulties[index]);
|
||
}
|
||
|
||
private async void RequestChangeRoomSong(SongData song, int difficultyId)
|
||
{
|
||
if (_service == null || song == null || _isChangingRoomSong)
|
||
{
|
||
return;
|
||
}
|
||
|
||
ArenaRoomSnapshot snapshot = _service.CurrentRoom;
|
||
string localSteamId = NetworkManager.Instance != null ? NetworkManager.Instance.SteamId : string.Empty;
|
||
if (!IsLocalHost(snapshot, localSteamId) || IsRoomStarted(snapshot))
|
||
{
|
||
RefreshSongDropdowns(snapshot);
|
||
return;
|
||
}
|
||
|
||
string difficultyKey = ConvertDifficultyIdToKey(difficultyId);
|
||
if (snapshot != null
|
||
&& string.Equals(snapshot.song_id, song.songID.ToString(CultureInfo.InvariantCulture), StringComparison.Ordinal)
|
||
&& string.Equals((snapshot.difficulty ?? string.Empty).Trim(), difficultyKey, StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
return;
|
||
}
|
||
|
||
_isChangingRoomSong = true;
|
||
UpdateSongDropdownInteractable(snapshot);
|
||
try
|
||
{
|
||
await _service.ChangeRoomSong(
|
||
song.songID.ToString(CultureInfo.InvariantCulture),
|
||
song.songName,
|
||
difficultyKey);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"[roomDetails] Change room song failed: {ex.Message}");
|
||
RefreshSongDropdowns(_service.CurrentRoom);
|
||
}
|
||
finally
|
||
{
|
||
_isChangingRoomSong = false;
|
||
UpdateSongDropdownInteractable(_service.CurrentRoom);
|
||
}
|
||
}
|
||
|
||
private SongData GetSelectedSong()
|
||
{
|
||
if (songDropdown == null)
|
||
{
|
||
return ResolveSnapshotSong(_service != null ? _service.CurrentRoom : null);
|
||
}
|
||
|
||
int index = songDropdown.value;
|
||
return index >= 0 && index < _selectableSongs.Count ? _selectableSongs[index] : null;
|
||
}
|
||
|
||
private int GetSelectedDifficultyId()
|
||
{
|
||
if (difficultyDropdown != null)
|
||
{
|
||
int index = difficultyDropdown.value;
|
||
if (index >= 0 && index < _selectableDifficulties.Count)
|
||
{
|
||
return _selectableDifficulties[index];
|
||
}
|
||
}
|
||
|
||
return ConvertDifficultyKeyToId(_service != null && _service.CurrentRoom != null ? _service.CurrentRoom.difficulty : null);
|
||
}
|
||
|
||
private static bool HasPlayableDifficulty(SongData song)
|
||
{
|
||
if (song == null || song.chartFiles == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
foreach (ChartFileEntry entry in song.chartFiles)
|
||
{
|
||
if (entry != null && entry.chartFile != null)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
private static string FormatDifficultyOption(SongData song, int difficultyId)
|
||
{
|
||
string shortName = FormatDifficulty(ConvertDifficultyIdToKey(difficultyId));
|
||
ChartFileEntry entry = song != null && song.chartFiles != null
|
||
? song.chartFiles.Find(item => item != null && item.difficulty == difficultyId)
|
||
: null;
|
||
|
||
if (entry != null && entry.difficultyLEVEL > 0f)
|
||
{
|
||
return $"{shortName} Lv.{entry.difficultyLEVEL:0.#}";
|
||
}
|
||
|
||
return shortName;
|
||
}
|
||
|
||
private static int ConvertDifficultyKeyToId(string difficultyKey)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(difficultyKey))
|
||
{
|
||
return 2;
|
||
}
|
||
|
||
switch (difficultyKey.Trim().ToLowerInvariant())
|
||
{
|
||
case "ez":
|
||
return 0;
|
||
case "hd":
|
||
return 1;
|
||
case "im":
|
||
return 3;
|
||
case "in":
|
||
default:
|
||
return 2;
|
||
}
|
||
}
|
||
|
||
private static string ConvertDifficultyIdToKey(int difficultyId)
|
||
{
|
||
switch (difficultyId)
|
||
{
|
||
case 0:
|
||
return "ez";
|
||
case 1:
|
||
return "hd";
|
||
case 3:
|
||
return "im";
|
||
case 2:
|
||
default:
|
||
return "in";
|
||
}
|
||
}
|
||
|
||
private static void SetButtonText(Button button, string text)
|
||
{
|
||
if (button == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
Text label = button.GetComponentInChildren<Text>(true);
|
||
if (label != null)
|
||
{
|
||
label.text = text;
|
||
}
|
||
}
|
||
|
||
private static string FormatDifficulty(string difficulty)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(difficulty))
|
||
{
|
||
return string.Empty;
|
||
}
|
||
|
||
switch (difficulty.Trim().ToLowerInvariant())
|
||
{
|
||
case "ez":
|
||
return "EZ";
|
||
case "hd":
|
||
return "HD";
|
||
case "in":
|
||
return "IN";
|
||
case "im":
|
||
return "IM";
|
||
default:
|
||
return difficulty;
|
||
}
|
||
}
|
||
|
||
private int GetEffectiveCacheLimit()
|
||
{
|
||
return Mathf.Max(InitialHistoryLoadLimit, Mathf.Max(1, maxMessageHistory));
|
||
}
|
||
|
||
private int GetEffectiveDisplayWindow()
|
||
{
|
||
return Mathf.Clamp(messageDisplayWindow, 1, MaxDisplayWindowLimit);
|
||
}
|
||
|
||
private int GetRenderedChatWindowCapacity()
|
||
{
|
||
return Mathf.Max(GetEffectiveDisplayWindow(), Mathf.Min(GetEffectiveCacheLimit(), GetEffectiveDisplayWindow() * 3));
|
||
}
|
||
}
|
||
|