浏览代码

Merge pull request #32 from Unity-Technologies/master-staging

fix: latest prod packages
/main
GitHub 1年前
当前提交
490c82ed
共有 20 个文件被更改,包括 1604 次插入1473 次删除
  1. 992
      Assets/Art/Font/CheckboxFLF SDF.asset
  2. 13
      Assets/Prefabs/NGO/InGameLogic.prefab
  3. 75
      Assets/Scripts/GameLobby/Game/GameManager.cs
  4. 132
      Assets/Scripts/GameLobby/Game/LocalLobby.cs
  5. 2
      Assets/Scripts/GameLobby/Infrastructure/Messenger.cs
  6. 31
      Assets/Scripts/GameLobby/Lobby/LobbyAPIInterface.cs
  7. 148
      Assets/Scripts/GameLobby/Lobby/LobbyAsyncRequests.cs
  8. 32
      Assets/Scripts/GameLobby/Vivox/VivoxUserHandler.cs
  9. 28
      Packages/manifest.json
  10. 136
      Packages/packages-lock.json
  11. 2
      ProjectSettings/GraphicsSettings.asset
  12. 11
      ProjectSettings/ProjectSettings.asset
  13. 4
      ProjectSettings/ProjectVersion.txt
  14. 999
      ~Documentation/Images/2_lobby.PNG
  15. 138
      Assets/Scripts/GameLobby/Lobby/LobbyContentUpdater.cs
  16. 105
      Assets/Scripts/GameLobby/Lobby/LobbyConverters.cs
  17. 76
      Assets/Scripts/GameLobby/Lobby/ToLocalLobby.cs
  18. 153
      Assets/Scripts/GameLobby/Lobby/LobbyContentHeartbeat.cs
  19. 0
      /Assets/Scripts/GameLobby/Lobby/LobbyConverters.cs.meta
  20. 0
      /Assets/Scripts/GameLobby/Lobby/LobbyContentUpdater.cs.meta

992
Assets/Art/Font/CheckboxFLF SDF.asset
文件差异内容过多而无法显示
查看文件

13
Assets/Prefabs/NGO/InGameLogic.prefab


m_Script: {fileID: 11500000, guid: 593a2fe42fa9d37498c96f9a383b6521, type: 3}
m_Name:
m_EditorClassIdentifier:
DontDestroy: 1
RunInBackground: 0
LogLevel: 1
NetworkConfig:

m_Name:
m_EditorClassIdentifier:
m_ProtocolType: 1
m_MaxPacketQueueSize: 256
m_MaxPayloadSize: 6144
m_MaxSendQueueSize: 98304
m_MaximumPacketSize: 1400
m_MaxPacketQueueSize: 512
m_SendQueueBatchSize: 6144
m_HeartbeatTimeoutMS: 500
m_ConnectTimeoutMS: 1000
m_MaxConnectAttempts: 60

Port: 7777
ServerListenAddress:
DebugSimulator:
PacketDelayMS: 0
PacketJitterMS: 0
PacketDropRate: 0
--- !u!1 &413870477192997562
GameObject:
m_ObjectHideFlags: 0

serializedVersion: 2
m_Bits: 1
m_VolumeTrigger: {fileID: 0}
m_VolumeFrameworkUpdateModeOption: 2
m_RenderPostProcessing: 0
m_Antialiasing: 0
m_AntialiasingQuality: 2

75
Assets/Scripts/GameLobby/Game/GameManager.cs


public class GameManager : MonoBehaviour, IReceiveMessages
{
#region UI elements that observe the local state. These should be assigned the observers in the scene during Start.
/// <summary>
/// The Observer/Observed Pattern is great for keeping the UI in Sync with the actual Values.
/// Each list below represents a single Observed class that gets updated by other parts of the code, and will

/// </summary>
[SerializeField]
private List<LocalMenuStateObserver> m_LocalMenuStateObservers = new List<LocalMenuStateObserver>();
[SerializeField]

private LobbyUser m_localUser;
private LocalLobby m_localLobby;
private LobbyServiceData m_lobbyServiceData = new LobbyServiceData();
private LobbyContentHeartbeat m_lobbyContentHeartbeat = new LobbyContentHeartbeat();
private LobbyContentUpdater m_LobbyContentUpdater = new LobbyContentUpdater();
private RelayUtpSetup m_relaySetup;
private RelayUtpClient m_relayClient;

private void OnAuthSignIn()
{
Debug.Log("Signed in.");
m_localUser.ID = Locator.Get.Identity.GetSubIdentity(Auth.IIdentityType.Auth).GetContent("id");
m_localUser.DisplayName = NameGenerator.GetName(m_localUser.ID);
m_localLobby.AddPlayer(m_localUser); // The local LobbyUser object will be hooked into UI before the LocalLobby is populated during lobby join, so the LocalLobby must know about it already when that happens.

/// <summary>
/// TODO Wire is a good update to remove the monolithic observers and move to observed values instead, on a Singleton gameManager
/// </summary>
private void BeginObservers()
{
foreach (var gameStateObs in m_LocalMenuStateObservers)

foreach (var userObs in m_LocalUserObservers)
userObs.BeginObserving(m_localUser);
}
#endregion
/// <summary>

{
LocalLobby.LobbyData createLobbyData = (LocalLobby.LobbyData)msg;
LobbyAsyncRequests.Instance.CreateLobbyAsync(createLobbyData.LobbyName, createLobbyData.MaxPlayerCount, createLobbyData.Private, m_localUser, (r) =>
{ lobby.ToLocalLobby.Convert(r, m_localLobby);
{
lobby.LobbyConverters.RemoteToLocal(r, m_localLobby);
OnCreatedLobby();
},
OnFailedJoin);

LocalLobby.LobbyData lobbyInfo = (LocalLobby.LobbyData)msg;
LobbyAsyncRequests.Instance.JoinLobbyAsync(lobbyInfo.LobbyID, lobbyInfo.LobbyCode, m_localUser, (r) =>
{ lobby.ToLocalLobby.Convert(r, m_localLobby);
{
lobby.LobbyConverters.RemoteToLocal(r, m_localLobby);
OnJoinedLobby();
},
OnFailedJoin);

m_lobbyServiceData.State = LobbyQueryState.Fetching;
LobbyAsyncRequests.Instance.RetrieveLobbyListAsync(
qr => {
qr =>
{
OnLobbiesQueried(lobby.ToLocalLobby.Convert(qr));
OnLobbiesQueried(lobby.LobbyConverters.QueryToLocalList(qr));
er => {
er =>
{
OnLobbyQueryFailed();
},
m_lobbyColorFilter);

LobbyAsyncRequests.Instance.QuickJoinLobbyAsync(m_localUser, m_lobbyColorFilter, (r) =>
{ lobby.ToLocalLobby.Convert(r, m_localLobby);
{
lobby.LobbyConverters.RemoteToLocal(r, m_localLobby);
OnJoinedLobby();
},
OnFailedJoin);

{
Locator.Get.Messenger.OnReceiveMessage(MessageType.DisplayErrorPopup, "Empty Name not allowed."); // Lobby error type, then HTTP error type.
return;
}
}
{ ConfirmApproval();
{
ConfirmApproval();
{ EmoteType emote = (EmoteType)msg;
{
EmoteType emote = (EmoteType)msg;
{ m_localUser.UserStatus = (UserStatus)msg;
{
m_localUser.UserStatus = (UserStatus)msg;
{ m_localLobby.State = LobbyState.CountDown;
{
m_localLobby.State = LobbyState.CountDown;
{ m_localLobby.State = LobbyState.Lobby;
{
m_localLobby.State = LobbyState.Lobby;
{ if (m_relayClient is RelayUtpHost)
{
if (m_relayClient is RelayUtpHost)
{ SetGameState((GameState)msg);
{
SetGameState((GameState)msg);
{ m_localUser.UserStatus = UserStatus.InGame;
{
m_localUser.UserStatus = UserStatus.InGame;
{ m_localLobby.State = LobbyState.Lobby;
{
m_localLobby.State = LobbyState.Lobby;
SetUserLobbyState();
}
}

private void OnJoinedLobby()
{
LobbyAsyncRequests.Instance.BeginTracking(m_localLobby.LobbyID);
m_lobbyContentHeartbeat.BeginTracking(m_localLobby, m_localUser);
m_LobbyContentUpdater.BeginTracking(m_localLobby, m_localUser);
SetUserLobbyState();
// The host has the opportunity to reject incoming players, but to do so the player needs to connect to Relay without having game logic available.

{
m_localUser.ResetState();
LobbyAsyncRequests.Instance.LeaveLobbyAsync(m_localLobby.LobbyID, ResetLocalLobby);
m_lobbyContentHeartbeat.EndTracking();
LobbyAsyncRequests.Instance.EndTracking();
m_LobbyContentUpdater.EndTracking();
{ Component.Destroy(m_relaySetup);
{
Component.Destroy(m_relaySetup);
if (m_relayClient != null)
{
m_relayClient.Dispose();

void OnVivoxLoginComplete(bool didSucceed)
{
if (!didSucceed)
{ Debug.LogError("Vivox login failed! Retrying in 5s...");
{
Debug.LogError("Vivox login failed! Retrying in 5s...");
StartCoroutine(RetryConnection(StartVivoxLogin, m_localLobby.LobbyID));
}
}

void OnVivoxJoinComplete(bool didSucceed)
{
if (!didSucceed)
{ Debug.LogError("Vivox connection failed! Retrying in 5s...");
{
Debug.LogError("Vivox connection failed! Retrying in 5s...");
StartCoroutine(RetryConnection(StartVivoxJoin, m_localLobby.LobbyID));
}
}

m_relaySetup = null;
if (!didSucceed)
{ Debug.LogError("Relay connection failed! Retrying in 5s...");
{
Debug.LogError("Relay connection failed! Retrying in 5s...");
StartCoroutine(RetryConnection(StartRelayConnection, m_localLobby.LobbyID));
return;
}

132
Assets/Scripts/GameLobby/Game/LocalLobby.cs


using System;
using System.Collections.Generic;
using System.Text;
using UnityEngine.Serialization;
namespace LobbyRelaySample
{

InGame = 4
}
public enum LobbyColor { None = 0, Orange = 1, Green = 2, Blue = 3 }
public enum LobbyColor
{
None = 0,
Orange = 1,
Green = 2,
Blue = 3
}
/// <summary>
/// A local wrapper around a lobby's remote data, with additional functionality for providing that data to UI elements and tracking local player objects.

{
Dictionary<string, LobbyUser> m_LobbyUsers = new Dictionary<string, LobbyUser>();
public Dictionary<string, LobbyUser> LobbyUsers => m_LobbyUsers;
public bool canPullUpdate;
#region LocalLobbyData
#region LocalLobbyData
public struct LobbyData
{
public string LobbyID { get; set; }

public string LobbyName { get; set; }
public bool Private { get; set; }
public bool Locked { get; set; }
public int AvailableSlots { get; set; }
public int MaxPlayerCount { get; set; }
public LobbyState State { get; set; }
public LobbyColor Color { get; set; }

State_LastEdit = existing.State_LastEdit;
Color_LastEdit = existing.Color_LastEdit;
RelayNGOCode_LastEdit = existing.RelayNGOCode_LastEdit;
AvailableSlots = existing.AvailableSlots;
Locked = existing.Locked;
}
public LobbyData(string lobbyCode)

State_LastEdit = 0;
Color_LastEdit = 0;
RelayNGOCode_LastEdit = 0;
AvailableSlots = 4;
Locked = false;
}
private LobbyData m_data;
public LobbyData Data
{
get { return new LobbyData(m_data); }
public override string ToString()
{
StringBuilder sb = new StringBuilder("Lobby : ");
sb.AppendLine(LobbyName);
sb.Append("ID: ");
sb.AppendLine(LobbyID);
sb.Append("Code: ");
sb.AppendLine(LobbyCode);
sb.Append("Private: ");
sb.AppendLine(Private.ToString());
sb.Append("Locked: ");
sb.AppendLine(Locked.ToString());
sb.Append("Max Players: ");
sb.AppendLine(MaxPlayerCount.ToString());
sb.Append("AvailableSlots: ");
sb.AppendLine(AvailableSlots.ToString());
sb.Append("LobbyState: ");
sb.AppendLine(State.ToString());
sb.Append("Lobby State Last Edit: ");
sb.AppendLine(new DateTime(State_LastEdit).ToString());
sb.Append("LobbyColor: ");
sb.AppendLine(Color.ToString());
sb.Append("Color Last Edit: ");
sb.AppendLine(new DateTime(Color_LastEdit).ToString());
sb.Append("RelayCode: ");
sb.AppendLine(RelayCode);
sb.Append("RelayNGO: ");
sb.AppendLine(RelayNGOCode);
sb.Append("Relay NGO last Edit: ");
sb.AppendLine(new DateTime(RelayNGOCode_LastEdit).ToString());
return sb.ToString();
}
ServerAddress m_relayServer;
public LobbyData Data => m_Data;
LobbyData m_Data;
ServerAddress m_RelayServer;
get => m_relayServer;
get => m_RelayServer;
m_relayServer = value;
m_RelayServer = value;
OnChanged(this);
}
}

public string LobbyID
{
get => m_data.LobbyID;
get => m_Data.LobbyID;
m_data.LobbyID = value;
m_Data.LobbyID = value;
OnChanged(this);
}
}

get => m_data.LobbyCode;
get => m_Data.LobbyCode;
m_data.LobbyCode = value;
m_Data.LobbyCode = value;
OnChanged(this);
}
}

get => m_data.RelayCode;
get => m_Data.RelayCode;
m_data.RelayCode = value;
m_Data.RelayCode = value;
OnChanged(this);
}
}

get => m_data.RelayNGOCode;
get => m_Data.RelayNGOCode;
m_data.RelayNGOCode = value;
m_data.RelayNGOCode_LastEdit = DateTime.Now.Ticks;
m_Data.RelayNGOCode = value;
m_Data.RelayNGOCode_LastEdit = DateTime.Now.Ticks;
OnChanged(this);
}
}

get => m_data.LobbyName;
get => m_Data.LobbyName;
m_data.LobbyName = value;
m_Data.LobbyName = value;
OnChanged(this);
}
}

get => m_data.State;
get => m_Data.State;
m_data.State = value;
m_data.State_LastEdit = DateTime.Now.Ticks;
m_Data.State = value;
m_Data.State_LastEdit = DateTime.Now.Ticks;
get => m_data.Private;
get => m_Data.Private;
m_data.Private = value;
m_Data.Private = value;
OnChanged(this);
}
}

public int MaxPlayerCount
{
get => m_data.MaxPlayerCount;
get => m_Data.MaxPlayerCount;
m_data.MaxPlayerCount = value;
m_Data.MaxPlayerCount = value;
OnChanged(this);
}
}

get => m_data.Color;
get => m_Data.Color;
if (m_data.Color != value)
{ m_data.Color = value;
m_data.Color_LastEdit = DateTime.Now.Ticks;
if (m_Data.Color != value)
{
m_Data.Color = value;
m_Data.Color_LastEdit = DateTime.Now.Ticks;
OnChanged(this);
}
}

var pendingState = data.State;
var pendingColor = data.Color;
var pendingNgoCode = data.RelayNGOCode;
if (m_data.State_LastEdit > data.State_LastEdit)
pendingState = m_data.State;
if (m_data.Color_LastEdit > data.Color_LastEdit)
pendingColor = m_data.Color;
if (m_data.RelayNGOCode_LastEdit > data.RelayNGOCode_LastEdit)
pendingNgoCode = m_data.RelayNGOCode;
m_data = data;
m_data.State = pendingState;
m_data.Color = pendingColor;
m_data.RelayNGOCode = pendingNgoCode;
if (m_Data.State_LastEdit > data.State_LastEdit)
pendingState = m_Data.State;
if (m_Data.Color_LastEdit > data.Color_LastEdit)
pendingColor = m_Data.Color;
if (m_Data.RelayNGOCode_LastEdit > data.RelayNGOCode_LastEdit)
pendingNgoCode = m_Data.RelayNGOCode;
m_Data = data;
m_Data.State = pendingState;
m_Data.Color = pendingColor;
m_Data.RelayNGOCode = pendingNgoCode;
if (currUsers == null)
m_LobbyUsers = new Dictionary<string, LobbyUser>();

2
Assets/Scripts/GameLobby/Infrastructure/Messenger.cs


public class Messenger : IMessenger
{
private List<IReceiveMessages> m_receivers = new List<IReceiveMessages>();
private const float k_durationToleranceMs = 10;
private const float k_durationToleranceMs = 15;
// We need to handle subscribers who modify the receiver list, e.g. a subscriber who unsubscribes in their OnReceiveMessage.
private Queue<Action> m_pendingReceivers = new Queue<Action>();

31
Assets/Scripts/GameLobby/Lobby/LobbyAPIInterface.cs


IsPrivate = isPrivate,
Player = new Player(id: requesterUASId, data: localUserData)
};
var task = Lobbies.Instance.CreateLobbyAsync(lobbyName, maxPlayers, createOptions);
var task = LobbyService.Instance.CreateLobbyAsync(lobbyName, maxPlayers, createOptions);
var task = Lobbies.Instance.DeleteLobbyAsync(lobbyId);
var task = LobbyService.Instance.DeleteLobbyAsync(lobbyId);
AsyncRequestLobby.Instance.DoRequest(task, onComplete);
}

var task = Lobbies.Instance.JoinLobbyByCodeAsync(lobbyCode, joinOptions);
var task = LobbyService.Instance.JoinLobbyByCodeAsync(lobbyCode, joinOptions);
AsyncRequestLobby.Instance.DoRequest(task, onComplete);
}

var task = Lobbies.Instance.JoinLobbyByIdAsync(lobbyId, joinOptions);
var task = LobbyService.Instance.JoinLobbyByIdAsync(lobbyId, joinOptions);
AsyncRequestLobby.Instance.DoRequest(task, onComplete);
}

Player = new Player(id: requesterUASId, data: localUserData)
};
var task = Lobbies.Instance.QuickJoinLobbyAsync(joinRequest);
var task = LobbyService.Instance.QuickJoinLobbyAsync(joinRequest);
var task = Lobbies.Instance.RemovePlayerAsync(lobbyId, requesterUASId);
var task = LobbyService.Instance.RemovePlayerAsync(lobbyId, requesterUASId);
AsyncRequestLobby.Instance.DoRequest(task, onComplete);
}

Count = k_maxLobbiesToShow,
Filters = filters
};
var task = Lobbies.Instance.QueryLobbiesAsync(queryOptions);
var task = LobbyService.Instance.QueryLobbiesAsync(queryOptions);
var task = Lobbies.Instance.GetLobbyAsync(lobbyId);
var task = LobbyService.Instance.GetLobbyAsync(lobbyId);
AsyncRequestLobby.Instance.DoRequest(task, onComplete);
}

UpdateLobbyOptions updateOptions = new UpdateLobbyOptions { Data = data , IsLocked = shouldLock};
var task = Lobbies.Instance.UpdateLobbyAsync(lobbyId, updateOptions);
UpdateLobbyOptions updateOptions = new UpdateLobbyOptions { Data = data, IsLocked = shouldLock };
var task = LobbyService.Instance.UpdateLobbyAsync(lobbyId, updateOptions);
AsyncRequestLobby.Instance.DoRequest(task, onComplete);
}

AllocationId = allocationId,
ConnectionInfo = connectionInfo
};
var task = Lobbies.Instance.UpdatePlayerAsync(lobbyId, playerId, updateOptions);
var task = LobbyService.Instance.UpdatePlayerAsync(lobbyId, playerId, updateOptions);
public static void SubscribeToLobbyUpdates(string lobbyId, LobbyEventCallbacks lobbyEvent, Action<ILobbyEvents> onLobbySubscribed)
{
var task = LobbyService.Instance.SubscribeToLobbyEventsAsync(lobbyId, lobbyEvent);
AsyncRequestLobby.Instance.DoRequest(task, onLobbySubscribed);
}
var task = Lobbies.Instance.SendHeartbeatPingAsync(lobbyId);
var task = LobbyService.Instance.SendHeartbeatPingAsync(lobbyId);
AsyncRequestLobby.Instance.DoRequest(task, null);
}
}

148
Assets/Scripts/GameLobby/Lobby/LobbyAsyncRequests.cs


using System;
using System.Collections.Generic;
using Unity.Services.Authentication;
using Unity.Services.Lobbies;
using UnityEngine;
/// An abstraction layer between the direct calls into the Lobby API and the outcomes you actually want. E.g. you can request to get a readable list of
/// An abstraction layer between the direct calls into the Lobby API and the outcomes you actually want. E.g. you can request to get a readable list of
/// current lobbies and not need to make the query call directly.
/// </summary>
public class LobbyAsyncRequests

}
}
public LobbyAsyncRequests()
{
Locator.Get.UpdateSlow.Subscribe(UpdateLobby, 0.5f); // Shouldn't need to unsubscribe since this instance won't be replaced. 0.5s is arbitrary; the rate limits are tracked later.
}
#region Lobby
#region Once connected to a lobby, cache the local lobby object so we don't query for it for every lobby operation.
public Action<Lobby> onLobbyUpdated;
//Once connected to a lobby, cache the local lobby object so we don't query for it for every lobby operation.
private string m_currentLobbyId = null;
private Lobby m_lastKnownLobby;
public Lobby CurrentLobby => m_lastKnownLobby;
public void BeginTracking(string lobbyId)
{
m_currentLobbyId = lobbyId;
}
public void EndTracking()
{
m_currentLobbyId = null;
m_lastKnownLobby = null;
m_heartbeatTime = 0;
}
private void UpdateLobby(float unused)
{
if (!string.IsNullOrEmpty(m_currentLobbyId))
RetrieveLobbyAsync(m_currentLobbyId, OnComplete);
void OnComplete(Lobby lobby)
{
if (lobby != null)
{
m_lastKnownLobby = lobby;
}
}
}
Lobby m_RemoteLobby;
/// <summary>
/// Store the LobbySubscription so we can unsubscribe later.
/// </summary>
ILobbyEvents m_lobbySubscription;
LobbyEventCallbacks m_lobbyEvents = new LobbyEventCallbacks();
#endregion

return data;
}
void BeginListening(string lobbyID)
{
m_lobbyEvents = new LobbyEventCallbacks();
m_lobbyEvents.LobbyChanged += OnRemoteLobbyChanged;
LobbyAPIInterface.SubscribeToLobbyUpdates(lobbyID, m_lobbyEvents, sub =>
{
m_lobbySubscription = sub;
m_lobbySubscription.SubscribeAsync();
});
}
void EndListening()
{
if (m_lobbySubscription == null)
{
Debug.LogError("Can't End listening without first listening to the lobby Callbacks.");
return;
}
m_lobbySubscription.UnsubscribeAsync();
m_RemoteLobby = null;
m_lobbySubscription = null;
m_lobbyEvents = null;
}
void OnRemoteLobbyChanged(ILobbyChanges changes)
{
if (changes.LobbyDeleted)
{
EndListening();
return;
}
//Synching the cloud lobby
changes.ApplyToLobby(m_RemoteLobby);
onLobbyUpdated?.Invoke(m_RemoteLobby);
}
/// <summary>
/// Attempt to create a new lobby and then join it.
/// </summary>

if (response == null)
onFailure?.Invoke();
else
{
JoinLobby(response);
}
}
}

if (response == null)
onFailure?.Invoke();
else
{
JoinLobby(response);
}
}
}

if (response == null)
onFailure?.Invoke();
else
{
JoinLobby(response);
}
void JoinLobby(Lobby response)
{
m_RemoteLobby = response;
BeginListening(m_RemoteLobby.Id);
}
/// <summary>
/// Used for getting the list of all active lobbies, without needing full info for each.
/// </summary>

Debug.Log("Retrieving Lobby List");
if (!m_rateLimitQuery.CanCall())
{
onListRetrieved?.Invoke(null);

return filters;
}
/// <param name="onComplete">If no lobby is retrieved, or if this call hits the rate limit, this is given null.</param>
private void RetrieveLobbyAsync(string lobbyId, Action<Lobby> onComplete)
{
if (!m_rateLimitQuery.CanCall())
{
onComplete?.Invoke(null);
UnityEngine.Debug.LogWarning("Retrieve Lobby hit the rate limit.");
return;
}
LobbyAPIInterface.GetLobbyAsync(lobbyId, OnGet);
void OnGet(Lobby response)
{
onComplete?.Invoke(response); // FUTURE: Consider passing in the exception code here (and elsewhere) to, e.g., specifically handle a 404 indicating a Relay auto-disconnect.
}
}
/// <summary>
/// Attempt to leave a lobby, and then delete it if no players remain.
/// </summary>

void OnLeftLobby()
{
onComplete?.Invoke();
m_RemoteLobby = null;
EndListening();
// Lobbies will automatically delete the lobby if unoccupied, so we don't need to take further action.
}

dataCurr.Add(dataNew.Key, dataObj);
}
LobbyAPIInterface.UpdatePlayerAsync(m_lastKnownLobby.Id, playerId, dataCurr, (result) => {
if (result != null)
m_lastKnownLobby = result; // Store the most up-to-date lobby now since we have it, instead of waiting for the next heartbeat.
LobbyAPIInterface.UpdatePlayerAsync(m_RemoteLobby.Id, playerId, dataCurr, (result) =>
{
onComplete?.Invoke();
}, null, null);
}

if (!ShouldUpdateData(() => { UpdatePlayerRelayInfoAsync(allocationId, connectionInfo, onComplete); }, onComplete, true)) // Do retry here since the RelayUtpSetup that called this might be destroyed right after this.
return;
string playerId = Locator.Get.Identity.GetSubIdentity(Auth.IIdentityType.Auth).GetContent("id");
LobbyAPIInterface.UpdatePlayerAsync(m_lastKnownLobby.Id, playerId, new Dictionary<string, PlayerDataObject>(), (r) => { onComplete?.Invoke(); }, allocationId, connectionInfo);
LobbyAPIInterface.UpdatePlayerAsync(m_RemoteLobby.Id, playerId, new Dictionary<string, PlayerDataObject>(), (r) => { onComplete?.Invoke(); }, allocationId, connectionInfo);
}
/// <param name="data">Key-value pairs, which will overwrite any existing data for these keys. Presumed to be available to all lobby members but not publicly.</param>

return;
Lobby lobby = m_lastKnownLobby;
Dictionary<string, DataObject> dataCurr = lobby.Data ?? new Dictionary<string, DataObject>();
Dictionary<string, DataObject> dataCurr = m_RemoteLobby.Data ?? new Dictionary<string, DataObject>();
var shouldLock = false;
var shouldLock = false;
foreach (var dataNew in data)
{
// Special case: We want to be able to filter on our color data, so we need to supply an arbitrary index to retrieve later. Uses N# for numerics, instead of S# for strings.

dataCurr[dataNew.Key] = dataObj;
else
dataCurr.Add(dataNew.Key, dataObj);
//Special Use: Get the state of the Local lobby so we can lock it from appearing in queries if it's not in the "Lobby" State
if (dataNew.Key == "State")
{

}
}
LobbyAPIInterface.UpdateLobbyAsync(lobby.Id, dataCurr, shouldLock, (result) =>
LobbyAPIInterface.UpdateLobbyAsync(m_RemoteLobby.Id, dataCurr, shouldLock, (result) =>
m_lastKnownLobby = result;
m_RemoteLobby = result;
onComplete?.Invoke();
});
}

return false;
}
Lobby lobby = m_lastKnownLobby;
if (lobby == null)
if (m_RemoteLobby == null)
{
if (shouldRetryIfLobbyNull)
m_rateLimitQuery.EnqueuePendingOperation(caller);

if (m_heartbeatTime > k_heartbeatPeriod)
{
m_heartbeatTime -= k_heartbeatPeriod;
LobbyAPIInterface.HeartbeatPlayerAsync(m_lastKnownLobby.Id);
LobbyAPIInterface.HeartbeatPlayerAsync(m_RemoteLobby.Id);
}
}

public void EnqueuePendingOperation(Action action)
{
//We probably dont want many of the same actions added to fire off multiple times.
if (!m_pendingOperations.Contains(action))
return;
m_pendingOperations.Enqueue(action);
}

32
Assets/Scripts/GameLobby/Vivox/VivoxUserHandler.cs


private string m_vivoxId;
private const int k_volumeMin = -50, k_volumeMax = 20; // From the Vivox docs, the valid range is [-50, 50] but anything above 25 risks being painfully loud.
public static float NormalizedVolumeDefault { get { return (0f - k_volumeMin) / (k_volumeMax - k_volumeMin); } }
public static float NormalizedVolumeDefault
{
get { return (0f - k_volumeMin) / (k_volumeMax - k_volumeMin); }
}
public void Start()
{

public void SetId(string id)
{
m_id = id;
// Vivox appends additional info to the ID we provide, in order to associate it with a specific channel. We'll construct m_vivoxId to match the ID used by Vivox.
// FUTURE: This isn't yet available. When using Auth, the Vivox ID will match this format:
// Account account = new Account(id);

bool isThisUser = username == m_id;
if (isThisUser)
{ m_vivoxId = keyEventArg.Key; // Since we couldn't construct the Vivox ID earlier, retrieve it here.
{
m_vivoxId = keyEventArg.Key; // Since we couldn't construct the Vivox ID earlier, retrieve it here.
if(!participant.IsMutedForAll)
m_lobbyUserVolumeUI.EnableVoice(false);//Should check if user is muted or not.
if (!participant.IsMutedForAll)
m_lobbyUserVolumeUI.EnableVoice(false); //Should check if user is muted or not.
if(!participant.LocalMute)
m_lobbyUserVolumeUI.EnableVoice(false);//Should check if user is muted or not.
if (!participant.LocalMute)
m_lobbyUserVolumeUI.EnableVoice(false); //Should check if user is muted or not.
else
m_lobbyUserVolumeUI.DisableVoice(false);
}

bool isThisUser = username == m_id;
if (isThisUser)
{ m_lobbyUserVolumeUI.DisableVoice(true);
{
m_lobbyUserVolumeUI.DisableVoice(true);
private void OnParticipantValueUpdated(object sender, ValueEventArg<string, IParticipant> valueEventArg)
{
var source = (VivoxUnity.IReadOnlyDictionary<string, IParticipant>)sender;

if (property == "UnavailableCaptureDevice")
{
if (participant.UnavailableCaptureDevice)
{ m_lobbyUserVolumeUI.DisableVoice(false);
participant.SetIsMuteForAll(m_vivoxId, true, null); // Note: If you add more places where a player might be globally muted, a state machine might be required for accurate logic.
{
m_lobbyUserVolumeUI.DisableVoice(false);
participant.SetIsMuteForAll(true, null); // Note: If you add more places where a player might be globally muted, a state machine might be required for accurate logic.
{ m_lobbyUserVolumeUI.EnableVoice(false);
participant.SetIsMuteForAll(m_vivoxId, false, null); // Also note: This call is asynchronous, so it's possible to exit the lobby before this completes, resulting in a Vivox error.
{
m_lobbyUserVolumeUI.EnableVoice(false);
participant.SetIsMuteForAll(false, null); // Also note: This call is asynchronous, so it's possible to exit the lobby before this completes, resulting in a Vivox error.
}
}
else if (property == "IsMutedForAll")

28
Packages/manifest.json


{
"dependencies": {
"com.unity.2d.sprite": "1.0.0",
"com.unity.collab-proxy": "1.11.2",
"com.unity.collab-proxy": "1.15.13",
"com.unity.ide.visualstudio": "2.0.11",
"com.unity.ide.vscode": "1.2.4",
"com.unity.netcode.adapter.utp": "1.0.0-pre.6",
"com.unity.netcode.gameobjects": "1.0.0-pre.6",
"com.unity.ide.visualstudio": "2.0.14",
"com.unity.ide.vscode": "1.2.5",
"com.unity.netcode.adapter.utp": "1.0.0-pre.3",
"com.unity.netcode.gameobjects": "1.0.0-pre.2",
"com.unity.render-pipelines.universal": "10.6.0",
"com.unity.services.authentication": "1.0.0-pre.6",
"com.unity.services.core": "1.1.0-pre.11",
"com.unity.services.lobby": "1.0.0-pre.6",
"com.unity.services.relay": "1.0.1-pre.3",
"com.unity.services.vivox": "15.1.150002-pre.1",
"com.unity.render-pipelines.universal": "10.8.1",
"com.unity.services.authentication": "2.3.1",
"com.unity.services.core": "1.2.0",
"com.unity.services.lobby": "1.0.3",
"com.unity.services.relay": "1.0.4",
"com.unity.services.vivox": "15.1.190000-pre.1",
"com.unity.services.wire": "1.1.0",
"com.unity.test-framework": "1.1.29",
"com.unity.test-framework": "1.1.31",
"com.unity.textmeshpro": "3.0.6",
"com.unity.toolchain.win-x86_64-linux-x86_64": "0.1.20-preview",
"com.unity.transport": "1.0.0-pre.9",

"com.unity.modules.vr": "1.0.0",
"com.unity.modules.wind": "1.0.0",
"com.unity.modules.xr": "1.0.0"
},
"scopedRegistries": []
}
}

136
Packages/packages-lock.json


"dependencies": {}
},
"com.unity.burst": {
"version": "1.6.4",
"version": "1.6.6",
"depth": 2,
"source": "registry",
"dependencies": {

},
"com.unity.collab-proxy": {
"version": "1.11.2",
"version": "1.15.13",
"dependencies": {},
"dependencies": {
"com.unity.services.core": "1.0.1"
},
"version": "1.1.0",
"depth": 1,
"version": "1.2.4",
"depth": 2,
"com.unity.burst": "1.5.4",
"com.unity.test-framework": "1.1.29"
"com.unity.burst": "1.6.6",
"com.unity.test-framework": "1.1.31"
},
"url": "https://packages.unity.com"
},

"url": "https://packages.unity.com"
},
"com.unity.ide.visualstudio": {
"version": "2.0.11",
"version": "2.0.14",
"depth": 0,
"source": "registry",
"dependencies": {

},
"com.unity.ide.vscode": {
"version": "1.2.4",
"version": "1.2.5",
"depth": 0,
"source": "registry",
"dependencies": {},

"version": "1.2.5",
"version": "1.2.6",
"depth": 2,
"source": "registry",
"dependencies": {},

"version": "1.0.0-pre.6",
"version": "1.0.0-pre.3",
"com.unity.netcode.gameobjects": "1.0.0-pre.6",
"com.unity.transport": "1.0.0-pre.14"
"com.unity.netcode.gameobjects": "1.0.0-pre.3",
"com.unity.transport": "1.0.0-pre.7"
"version": "1.0.0-pre.6",
"depth": 0,
"version": "1.0.0-pre.3",
"depth": 1,
"com.unity.modules.ai": "1.0.0",
"com.unity.modules.physics": "1.0.0",
"com.unity.modules.physics2d": "1.0.0",
"com.unity.collections": "1.1.0"
"com.unity.collections": "1.0.0-pre.5"
},
"url": "https://packages.unity.com"
},

"url": "https://packages.unity.com"
},
"com.unity.nuget.newtonsoft-json": {
"version": "2.0.0",
"depth": 0,
"version": "3.0.2",
"depth": 1,
"version": "10.6.0",
"version": "10.8.1",
"com.unity.ugui": "1.0.0"
"com.unity.ugui": "1.0.0",
"com.unity.modules.physics": "1.0.0",
"com.unity.modules.jsonserialize": "1.0.0"
"version": "10.6.0",
"version": "10.8.1",
"com.unity.render-pipelines.core": "10.6.0",
"com.unity.shadergraph": "10.6.0"
"com.unity.render-pipelines.core": "10.8.1",
"com.unity.shadergraph": "10.8.1"
},
"url": "https://packages.unity.com"
},

"url": "https://packages.unity.com"
},
"com.unity.services.authentication": {
"version": "1.0.0-pre.6",
"version": "2.3.1",
"com.unity.nuget.newtonsoft-json": "2.0.0",
"com.unity.services.core": "1.1.0-pre.9",
"com.unity.modules.unitywebrequest": "1.0.0"
"com.unity.nuget.newtonsoft-json": "3.0.2",
"com.unity.services.core": "1.4.3",
"com.unity.modules.unitywebrequest": "1.0.0",
"com.unity.ugui": "1.0.0"
"version": "1.1.0-pre.11",
"depth": 0,
"version": "1.4.3",
"depth": 1,
"com.unity.nuget.newtonsoft-json": "2.0.0"
"com.unity.nuget.newtonsoft-json": "3.0.2",
"com.unity.modules.androidjni": "1.0.0"
"version": "1.0.0-pre.6",
"version": "1.0.3",
"com.unity.services.core": "1.1.0-pre.10",
"com.unity.services.core": "1.4.0",
"com.unity.nuget.newtonsoft-json": "2.0.0",
"com.unity.services.authentication": "1.0.0-pre.6"
"com.unity.nuget.newtonsoft-json": "3.0.2",
"com.unity.services.authentication": "2.0.0"
},
"url": "https://packages.unity.com"
},
"com.unity.services.qos": {
"version": "1.0.2",
"depth": 1,
"source": "registry",
"dependencies": {
"com.unity.services.core": "1.4.0",
"com.unity.modules.unitywebrequest": "1.0.0",
"com.unity.nuget.newtonsoft-json": "3.0.2",
"com.unity.services.authentication": "2.0.0",
"com.unity.collections": "1.2.4"
"version": "1.0.1-pre.3",
"version": "1.0.4",
"com.unity.services.core": "1.1.0-pre.10",
"com.unity.services.core": "1.4.0",
"com.unity.services.authentication": "2.0.0",
"com.unity.services.qos": "1.0.2",
"com.unity.nuget.newtonsoft-json": "2.0.0",
"com.unity.services.authentication": "1.0.0-pre.6",
"com.unity.transport": "1.0.0-pre.6"
"com.unity.nuget.newtonsoft-json": "3.0.2",
"com.unity.transport": "1.1.0"
"version": "15.1.150002-pre.1",
"version": "15.1.190000-pre.1",
"com.unity.settings-manager": "1.0.3",
"com.unity.services.core": "1.1.0-pre.8",
"com.unity.nuget.newtonsoft-json": "2.0.0"
"com.unity.settings-manager": "2.0.0",
"com.unity.services.core": "1.3.1",
"com.unity.nuget.newtonsoft-json": "3.0.2"
},
"url": "https://packages.unity.com"
},
"com.unity.services.wire": {
"version": "1.1.0",
"depth": 0,
"source": "registry",
"dependencies": {
"com.unity.services.core": "1.4.2",
"com.unity.nuget.newtonsoft-json": "3.0.2",
"com.unity.services.authentication": "2.1.1"
"version": "1.0.3",
"version": "2.0.0",
"depth": 1,
"source": "registry",
"dependencies": {},

"version": "10.6.0",
"version": "10.8.1",
"com.unity.render-pipelines.core": "10.6.0",
"com.unity.render-pipelines.core": "10.8.1",
"com.unity.searcher": "4.3.2"
},
"url": "https://packages.unity.com"

"url": "https://packages.unity.com"
},
"com.unity.test-framework": {
"version": "1.1.29",
"version": "1.1.31",
"depth": 0,
"source": "registry",
"dependencies": {

"url": "https://packages.unity.com"
},
"com.unity.transport": {
"version": "1.0.0-pre.14",
"version": "1.1.0",
"com.unity.collections": "1.1.0",
"com.unity.burst": "1.6.4",
"com.unity.mathematics": "1.2.5"
"com.unity.collections": "1.2.4",
"com.unity.burst": "1.6.6",
"com.unity.mathematics": "1.2.6"
},
"url": "https://packages.unity.com"
},

2
ProjectSettings/GraphicsSettings.asset


- {fileID: 10783, guid: 0000000000000000f000000000000000, type: 0}
m_PreloadedShaders: []
m_SpritesDefaultMaterial: {fileID: 10754, guid: 0000000000000000f000000000000000, type: 0}
m_CustomRenderPipeline: {fileID: 11400000, guid: f54ab92f70892f44eba32f1c414f5b4a, type: 2}
m_CustomRenderPipeline: {fileID: 0}
m_TransparencySortMode: 0
m_TransparencySortAxis: {x: 0, y: 0, z: 1}
m_DefaultRenderingPath: 1

11
ProjectSettings/ProjectSettings.asset


androidSupportedAspectRatio: 1
androidMaxAspectRatio: 2.1
applicationIdentifier:
Standalone: com.unity.services.samples.lobby-rooms
Standalone: com.unity.services.samples.game-lobby
buildNumber:
Standalone: 0
iPhone: 0

switchPlayerConnectionEnabled: 1
switchUseNewStyleFilepaths: 0
switchUseMicroSleepForYield: 1
switchEnableRamDiskSupport: 0
switchRamDiskSpaceSize: 12
ps4NPAgeRating: 12
ps4NPTitleSecret:
ps4NPTrophyPackPath:

webGLLinkerTarget: 1
webGLThreadsSupport: 0
webGLDecompressionFallback: 0
scriptingDefineSymbols: {}
scriptingDefineSymbols:
1: UGS_BETA_LOBBY_EVENTS
additionalCompilerArguments: {}
platformArchitecture: {}
scriptingBackend: {}

metroFTAName:
metroFTAFileTypes: []
metroProtocolName:
vcxProjDefaultLanguage:
XboxOneProductId:
XboxOneUpdateKey:
XboxOneSandboxId:

XboxOneOverrideIdentityPublisher:
vrEditorSettings: {}
cloudServicesEnabled:
Analytics: 0
Analytics: 1
Legacy Analytics: 0
Purchasing: 0
UDP: 0
Unity Ads: 0

4
ProjectSettings/ProjectVersion.txt


m_EditorVersion: 2020.3.20f1
m_EditorVersionWithRevision: 2020.3.20f1 (41c4e627c95f)
m_EditorVersion: 2020.3.31f1
m_EditorVersionWithRevision: 2020.3.31f1 (6b54b7616050)

999
~Documentation/Images/2_lobby.PNG
文件差异内容过多而无法显示
查看文件

138
Assets/Scripts/GameLobby/Lobby/LobbyContentUpdater.cs


using System;
using LobbyRelaySample.lobby;
using Unity.Services.Lobbies.Models;
using UnityEngine;
namespace LobbyRelaySample
{
/// <summary>
/// Keep updated on changes to a joined lobby, at a speed compliant with Lobby's rate limiting.
/// </summary>
public class LobbyContentUpdater : IReceiveMessages
{
private LocalLobby m_LocalLobby;
private LobbyUser m_LocalUser;
private bool m_ShouldPushData = false;
private const float k_approvalMaxTime = 10; // Used for determining if a user should timeout if they are unable to connect.
private float m_lifetime = 0;
public void BeginTracking(LocalLobby localLobby, LobbyUser localUser)
{
m_LocalUser = localUser;
m_LocalLobby = localLobby;
m_LocalLobby.onChanged += OnLocalLobbyChanged;
m_ShouldPushData = true;
Locator.Get.Messenger.Subscribe(this);
Locator.Get.UpdateSlow.Subscribe(OnUpdate, 1.5f);
m_lifetime = 0;
LobbyAsyncRequests.Instance.onLobbyUpdated += OnRemoteLobbyUpdated;
}
public void EndTracking()
{
m_ShouldPushData = false;
Locator.Get.Messenger.Unsubscribe(this);
Locator.Get.UpdateSlow.Unsubscribe(OnUpdate);
if (m_LocalLobby != null)
m_LocalLobby.onChanged -= OnLocalLobbyChanged;
LobbyAsyncRequests.Instance.onLobbyUpdated -= OnRemoteLobbyUpdated;
m_LocalLobby = null;
}
public void OnReceiveMessage(MessageType type, object msg)
{
if (type == MessageType.ClientUserSeekingDisapproval)
{
bool shouldDisapprove = m_LocalLobby.State != LobbyState.Lobby; // By not refreshing, it's possible to have a lobby in the lobby list UI after its countdown starts and then try joining.
if (shouldDisapprove)
(msg as Action<relay.Approval>)?.Invoke(relay.Approval.GameAlreadyStarted);
}
}
void OnLocalLobbyChanged(LocalLobby changed)
{
if (string.IsNullOrEmpty(changed.LobbyID)) // When the player leaves, their LocalLobby is cleared out but maintained.
{
EndTracking();
return;
}
if (changed.canPullUpdate)
{
changed.canPullUpdate = false;
return;
}
m_ShouldPushData = true;
}
/// <summary>
/// If there have been any data changes since the last update, push them to Lobby. Regardless, pull for the most recent data.
/// (Unless we're already awaiting a query, in which case continue waiting.)
/// </summary>
private void OnUpdate(float dt)
{
m_lifetime += dt;
if (m_LocalLobby == null)
return;
if (m_LocalUser.IsHost)
LobbyAsyncRequests.Instance.DoLobbyHeartbeat(dt);
if (!m_LocalUser.IsApproved && m_lifetime > k_approvalMaxTime)
{
Locator.Get.Messenger.OnReceiveMessage(MessageType.DisplayErrorPopup, "Connection attempt timed out!");
Locator.Get.Messenger.OnReceiveMessage(MessageType.ChangeMenuState, GameState.JoinMenu);
}
if (m_ShouldPushData)
PushDataToLobby();
void PushDataToLobby()
{
m_ShouldPushData = false;
if (m_LocalUser.IsHost)
{
DoLobbyDataPush();
}
DoPlayerDataPush();
}
void DoLobbyDataPush()
{
LobbyAsyncRequests.Instance.UpdateLobbyDataAsync(LobbyConverters.LocalToRemoteData(m_LocalLobby), null);
}
void DoPlayerDataPush()
{
LobbyAsyncRequests.Instance.UpdatePlayerDataAsync(LobbyConverters.LocalToRemoteUserData(m_LocalUser), null);
}
}
void OnRemoteLobbyUpdated(Lobby lobby)
{
m_LocalLobby.canPullUpdate = true;
//synching our local lobby
LobbyConverters.RemoteToLocal(lobby, m_LocalLobby);
//Dont push data this tick, since we "pulled"s
if (!m_LocalUser.IsHost)
{
foreach (var lobbyUser in m_LocalLobby.LobbyUsers)
{
if (lobbyUser.Value.IsHost)
return;
}
Locator.Get.Messenger.OnReceiveMessage(MessageType.DisplayErrorPopup, "Host left the lobby! Disconnecting...");
Locator.Get.Messenger.OnReceiveMessage(MessageType.EndGame, null);
Locator.Get.Messenger.OnReceiveMessage(MessageType.ChangeMenuState, GameState.JoinMenu);
}
}
}
}

105
Assets/Scripts/GameLobby/Lobby/LobbyConverters.cs


using System.Collections.Generic;
using Unity.Services.Lobbies.Models;
using UnityEngine;
namespace LobbyRelaySample.lobby
{
/// <summary>
/// QueryToLocalList the lobby resulting from a request into a LocalLobby for use in the game logic.
/// </summary>
public static class LobbyConverters
{
public static Dictionary<string, string> LocalToRemoteData(LocalLobby lobby)
{
Dictionary<string, string> data = new Dictionary<string, string>();
data.Add("RelayCode", lobby.RelayCode);
data.Add("RelayNGOCode", lobby.RelayNGOCode);
data.Add("State", ((int)lobby.State).ToString()); // Using an int is smaller than using the enum state's name.
data.Add("Color", ((int)lobby.Color).ToString());
data.Add("State_LastEdit", lobby.Data.State_LastEdit.ToString());
data.Add("Color_LastEdit", lobby.Data.Color_LastEdit.ToString());
data.Add("RelayNGOCode_LastEdit", lobby.Data.RelayNGOCode_LastEdit.ToString());
return data;
}
public static Dictionary<string, string> LocalToRemoteUserData(LobbyUser user)
{
Dictionary<string, string> data = new Dictionary<string, string>();
if (user == null || string.IsNullOrEmpty(user.ID))
return data;
data.Add("DisplayName", user.DisplayName); // The lobby doesn't need to know any data beyond the name and state; Relay will handle the rest.
data.Add("UserStatus", ((int)user.UserStatus).ToString());
return data;
}
/// <summary>
/// Create a new LocalLobby from the content of a retrieved lobby. Its data can be copied into an existing LocalLobby for use.
/// </summary>
public static void RemoteToLocal(Lobby lobby, LocalLobby lobbyToUpdate)
{
//Copy Data from Lobby into Local lobby fields
LocalLobby.LobbyData info = new LocalLobby.LobbyData(lobbyToUpdate.Data)
{
LobbyID = lobby.Id,
LobbyCode = lobby.LobbyCode,
Private = lobby.IsPrivate,
LobbyName = lobby.Name,
MaxPlayerCount = lobby.MaxPlayers,
RelayCode = lobby.Data?.ContainsKey("RelayCode") == true ? lobby.Data["RelayCode"].Value : lobbyToUpdate.RelayCode, // By providing RelayCode through the lobby data with Member visibility, we ensure a client is connected to the lobby before they could attempt a relay connection, preventing timing issues between them.
RelayNGOCode = lobby.Data?.ContainsKey("RelayNGOCode") == true ? lobby.Data["RelayNGOCode"].Value : lobbyToUpdate.RelayNGOCode,
State = lobby.Data?.ContainsKey("State") == true ? (LobbyState)int.Parse(lobby.Data["State"].Value) : LobbyState.Lobby,
Color = lobby.Data?.ContainsKey("Color") == true ? (LobbyColor)int.Parse(lobby.Data["Color"].Value) : LobbyColor.None,
State_LastEdit = lobby.Data?.ContainsKey("State_LastEdit") == true ? long.Parse(lobby.Data["State_LastEdit"].Value) : lobbyToUpdate.Data.State_LastEdit,
Color_LastEdit = lobby.Data?.ContainsKey("Color_LastEdit") == true ? long.Parse(lobby.Data["Color_LastEdit"].Value) : lobbyToUpdate.Data.Color_LastEdit,
RelayNGOCode_LastEdit = lobby.Data?.ContainsKey("RelayNGOCode_LastEdit") == true ? long.Parse(lobby.Data["RelayNGOCode_LastEdit"].Value) : lobbyToUpdate.Data.RelayNGOCode_LastEdit
};
Dictionary<string, LobbyUser> lobbyUsers = new Dictionary<string, LobbyUser>();
foreach (var player in lobby.Players)
{
// If we already know about this player and this player is already connected to Relay, don't overwrite things that Relay might be changing.
if (player.Data?.ContainsKey("UserStatus") == true && int.TryParse(player.Data["UserStatus"].Value, out int status))
{
if (status > (int)UserStatus.Connecting && lobbyToUpdate.LobbyUsers.ContainsKey(player.Id))
{
lobbyUsers.Add(player.Id, lobbyToUpdate.LobbyUsers[player.Id]);
continue;
}
}
// If the player isn't connected to Relay, get the most recent data that the lobby knows.
// (If we haven't seen this player yet, a new local representation of the player will have already been added by the LocalLobby.)
LobbyUser incomingData = new LobbyUser
{
IsHost = lobby.HostId.Equals(player.Id),
DisplayName = player.Data?.ContainsKey("DisplayName") == true ? player.Data["DisplayName"].Value : default,
Emote = player.Data?.ContainsKey("Emote") == true ? (EmoteType)int.Parse(player.Data["Emote"].Value) : default,
UserStatus = player.Data?.ContainsKey("UserStatus") == true ? (UserStatus)int.Parse(player.Data["UserStatus"].Value) : UserStatus.Connecting,
ID = player.Id
};
lobbyUsers.Add(incomingData.ID, incomingData);
}
//Push all the data at once so we don't call OnChanged for each variable
lobbyToUpdate.CopyObserved(info, lobbyUsers);
}
/// <summary>
/// Create a list of new LocalLobbies from the result of a lobby list query.
/// </summary>
public static List<LocalLobby> QueryToLocalList(QueryResponse response)
{
List<LocalLobby> retLst = new List<LocalLobby>();
foreach (var lobby in response.Results)
retLst.Add(RemoteToNewLocal(lobby));
return retLst;
}
private static LocalLobby RemoteToNewLocal(Lobby lobby)
{
LocalLobby data = new LocalLobby();
RemoteToLocal(lobby, data);
return data;
}
}
}

76
Assets/Scripts/GameLobby/Lobby/ToLocalLobby.cs


using System.Collections.Generic;
using Unity.Services.Lobbies.Models;
namespace LobbyRelaySample.lobby
{
/// <summary>
/// Convert the lobby resulting from a request into a LocalLobby for use in the game logic.
/// </summary>
public static class ToLocalLobby
{
/// <summary>
/// Create a new LocalLobby from the content of a retrieved lobby. Its data can be copied into an existing LocalLobby for use.
/// </summary>
public static void Convert(Lobby lobby, LocalLobby outputToHere)
{
LocalLobby.LobbyData info = new LocalLobby.LobbyData // Technically, this is largely redundant after the first assignment, but it won't do any harm to assign it again.
{ LobbyID = lobby.Id,
LobbyCode = lobby.LobbyCode,
Private = lobby.IsPrivate,
LobbyName = lobby.Name,
MaxPlayerCount = lobby.MaxPlayers,
RelayCode = lobby.Data?.ContainsKey("RelayCode") == true ? lobby.Data["RelayCode"].Value : null, // By providing RelayCode through the lobby data with Member visibility, we ensure a client is connected to the lobby before they could attempt a relay connection, preventing timing issues between them.
RelayNGOCode = lobby.Data?.ContainsKey("RelayNGOCode") == true ? lobby.Data["RelayNGOCode"].Value : null,
State = lobby.Data?.ContainsKey("State") == true ? (LobbyState) int.Parse(lobby.Data["State"].Value) : LobbyState.Lobby,
Color = lobby.Data?.ContainsKey("Color") == true ? (LobbyColor) int.Parse(lobby.Data["Color"].Value) : LobbyColor.None,
State_LastEdit = lobby.Data?.ContainsKey("State_LastEdit") == true ? long.Parse(lobby.Data["State_LastEdit"].Value) : 0,
Color_LastEdit = lobby.Data?.ContainsKey("Color_LastEdit") == true ? long.Parse(lobby.Data["Color_LastEdit"].Value) : 0,
RelayNGOCode_LastEdit = lobby.Data?.ContainsKey("RelayNGOCode_LastEdit") == true ? long.Parse(lobby.Data["RelayNGOCode_LastEdit"].Value) : 0,
};
Dictionary<string, LobbyUser> lobbyUsers = new Dictionary<string, LobbyUser>();
foreach (var player in lobby.Players)
{
// If we already know about this player and this player is already connected to Relay, don't overwrite things that Relay might be changing.
if (player.Data?.ContainsKey("UserStatus") == true && int.TryParse(player.Data["UserStatus"].Value, out int status))
{
if (status > (int)UserStatus.Connecting && outputToHere.LobbyUsers.ContainsKey(player.Id))
{
lobbyUsers.Add(player.Id, outputToHere.LobbyUsers[player.Id]);
continue;