r2mods/ilspy_dump/ror2_csproj/RoR2/EOSLobbyManager.cs

1449 lines
46 KiB
C#
Raw Normal View History

2024-10-04 07:26:37 +00:00
using System;
using System.Collections.Generic;
using Epic.OnlineServices;
using Epic.OnlineServices.Lobby;
using Epic.OnlineServices.UI;
using Facepunch.Steamworks;
using HG;
using RoR2.Networking;
using RoR2.UI;
using UnityEngine;
using UnityEngine.Networking;
namespace RoR2;
public class EOSLobbyManager : PCLobbyManager
{
public class Filter
{
public List<AttributeData> SearchData = new List<AttributeData>();
}
private struct LobbyRefreshRequest
{
public object requester;
public Filter filter;
public Action<List<LobbyDetails>> callback;
}
private const MPFeatures PlatformFeatureFlags = MPFeatures.HostGame | MPFeatures.FindGame;
private const MPLobbyFeatures PlatformLobbyUIFlags = MPLobbyFeatures.CreateLobby | MPLobbyFeatures.SocialIcon | MPLobbyFeatures.HostPromotion | MPLobbyFeatures.Clipboard | MPLobbyFeatures.Invite | MPLobbyFeatures.UserIcon | MPLobbyFeatures.LeaveLobby | MPLobbyFeatures.LobbyDropdownOptions;
private bool _ownsLobby;
private int minimumPlayerCount = 2;
private string currentLobbyId = string.Empty;
private LobbyDetails currentLobbyDetails;
private LobbyModification currentLobbyModificationHandle;
private LobbySearch currentSearchHandle;
private LobbySearch joinClipboardLobbySearchHandle;
private const int MaxSearchResults = 50;
public const string mdEdition = "v";
public const string mdAppId = "appid";
public const string mdTotalMaxPlayers = "total_max_players";
public const string mdPlayerCount = "player_count";
public const string mdQuickplayQueued = "qp";
public const string mdQuickplayCutoffTime = "qp_cutoff_time";
public const string mdStarting = "starting";
public const string mdBuildId = "build_id";
public const string mdServerId = "server_id";
public const string mdServerAddress = "server_address";
public const string mdMap = "_map";
public const string mdRuleBook = "rulebook";
public const string mdMigrationId = "migration_id";
public const string mdHasPassword = "_pw";
public const string mdIsDedicatedServer = "_ds";
public const string mdServerName = "_svnm";
public const string mdServerTags = "_svtags";
public const string mdServerMaxPlayers = "_svmpl";
public const string mdServerPlayerCount = "_svplc";
public const string mdGameModeName = "_svgm";
public const string mdModHash = "_mh";
public const string BucketName = "gbx_internal";
private LobbyInterface lobbyInterface;
private readonly List<int> playerCountsList = new List<int>();
private MemoizedToString<int, ToStringImplementationInvariant> localPlayerCountToString = MemoizedToString<int, ToStringImplementationInvariant>.GetNew();
private const string LobbyJoinIndicator = "ClipboardJoin";
private bool startingFadeSet;
private string lastHostingLobbyId;
private const float quickplayCutoffTime = 30f;
private Queue<LobbyRefreshRequest> lobbyRefreshRequests = new Queue<LobbyRefreshRequest>();
private LobbyRefreshRequest? currentRefreshRequest;
private bool hostingServer;
private PlatformID currentServerId;
private static readonly char[] charactersToCheck = "abcdef".ToCharArray();
public override bool isInLobby
{
get
{
return currentLobbyId != string.Empty;
}
protected set
{
}
}
public override bool ownsLobby
{
get
{
return _ownsLobby;
}
protected set
{
if (value != _ownsLobby)
{
_ownsLobby = value;
if (_ownsLobby)
{
OnLobbyOwnershipGained();
UpdatePlayerCount();
}
else
{
OnLobbyOwnershipLost();
}
}
}
}
public override bool hasMinimumPlayerCount => newestLobbyData.totalPlayerCount >= minimumPlayerCount;
public int remoteMachineCount { get; private set; }
public string CurrentLobbyId
{
get
{
return currentLobbyId;
}
private set
{
}
}
public LobbyDetails CurrentLobbyDetails
{
get
{
return currentLobbyDetails;
}
private set
{
}
}
public LobbyModification CurrentLobbyModification
{
get
{
return currentLobbyModificationHandle;
}
private set
{
}
}
public PlatformID serverId => newestLobbyData.serverId;
public override LobbyData newestLobbyData { get; protected set; }
public override int calculatedTotalPlayerCount { get; protected set; }
public override int calculatedExtraPlayersCount { get; protected set; }
public override LobbyType currentLobbyType
{
get
{
if (currentLobbyDetails != null)
{
LobbyDetailsCopyInfoOptions options = default(LobbyDetailsCopyInfoOptions);
currentLobbyDetails.CopyInfo(ref options, out var outLobbyDetailsInfo);
return PermissionLevelToType(outLobbyDetailsInfo.Value.PermissionLevel);
}
return LobbyType.Error;
}
set
{
}
}
public override bool IsBusy { get; set; }
public override MPFeatures GetPlatformMPFeatureFlags()
{
return MPFeatures.HostGame | MPFeatures.FindGame;
}
public override MPLobbyFeatures GetPlatformMPLobbyFeatureFlags()
{
return MPLobbyFeatures.CreateLobby | MPLobbyFeatures.SocialIcon | MPLobbyFeatures.HostPromotion | MPLobbyFeatures.Clipboard | MPLobbyFeatures.Invite | MPLobbyFeatures.UserIcon | MPLobbyFeatures.LeaveLobby | MPLobbyFeatures.LobbyDropdownOptions;
}
public static EOSLobbyManager GetFromPlatformSystems()
{
return PlatformSystems.lobbyManager as EOSLobbyManager;
}
private void UpdateOwnsLobby()
{
LobbyDetailsGetLobbyOwnerOptions options = default(LobbyDetailsGetLobbyOwnerOptions);
ownsLobby = currentLobbyDetails != null && currentLobbyDetails.GetLobbyOwner(ref options) == EOSLoginManager.loggedInProductId;
}
public void Init()
{
lobbyInterface = EOSPlatformManager.GetPlatformInterface().GetLobbyInterface();
if (lobbyInterface == null)
{
Debug.LogError("Unable to Obtain EOS Lobby Interface!");
}
SetupLobbyCallbacks();
RoR2Application.onUpdate += StaticUpdate;
LobbyDataSetupState setupState = new LobbyDataSetupState
{
totalMaxPlayers = RoR2Application.maxPlayers
};
newestLobbyData = new LobbyData(setupState);
LocalUserManager.onLocalUsersUpdated += UpdatePlayerCount;
NetworkManagerSystem.onStartServerGlobal += OnStartHostingServer;
NetworkManagerSystem.onStopServerGlobal += OnStopHostingServer;
NetworkManagerSystem.onStopClientGlobal += OnStopClient;
NetworkManagerSystem.onStopClientGlobal += delegate
{
SetStartingIfOwner(startingState: false);
};
onLobbyOwnershipGained = (Action)Delegate.Combine(onLobbyOwnershipGained, (Action)delegate
{
SetStartingIfOwner(startingState: false);
});
UserManager.OnDisplayNameMappingComplete += UpdateLobbyNames;
SetStartingIfOwner(startingState: false);
SteamworksClientManager.onLoaded += SetSteamLobbyCallbacks;
}
public override void Shutdown()
{
base.Shutdown();
lobbyInterface = null;
}
private void SetSteamLobbyCallbacks()
{
Client steamworksClient = SteamworksClientManager.instance.steamworksClient;
steamworksClient.Lobby.OnUserInvitedToLobby = OnUserInvitedToSteamLobby;
steamworksClient.Lobby.OnLobbyJoinRequested = OnSteamLobbyJoinRequested;
}
private void OnSteamLobbyJoinRequested(ulong lobbyId)
{
Debug.LogFormat("Request to join lobby {0} received but we're in cross-play, rejecting", lobbyId);
PCLobbyManager.ShowEnableCrossPlayPopup(isLobbyCrossplay: false);
}
private void OnUserInvitedToSteamLobby(ulong lobbyId, ulong senderId)
{
Debug.LogFormat("Received invitation to lobby {0} from sender {1} but we're in cross play, rejecting", lobbyId, senderId);
}
private void UpdateLobbyNames()
{
onLobbyDataUpdated?.Invoke();
}
private void SetupLobbyCallbacks()
{
AddNotifyLobbyUpdateReceivedOptions options = default(AddNotifyLobbyUpdateReceivedOptions);
lobbyInterface.AddNotifyLobbyUpdateReceived(ref options, null, OnLobbyDataUpdateReceived);
AddNotifyJoinLobbyAcceptedOptions options2 = default(AddNotifyJoinLobbyAcceptedOptions);
lobbyInterface.AddNotifyJoinLobbyAccepted(ref options2, null, OnJoinLobbyAccepted);
AddNotifyLobbyInviteReceivedOptions options3 = default(AddNotifyLobbyInviteReceivedOptions);
lobbyInterface.AddNotifyLobbyInviteReceived(ref options3, null, OnUserInvitedToLobby);
AddNotifyLobbyInviteAcceptedOptions options4 = default(AddNotifyLobbyInviteAcceptedOptions);
lobbyInterface.AddNotifyLobbyInviteAccepted(ref options4, null, OnLobbyInviteAccepted);
}
public override int GetLobbyMemberPlayerCountByIndex(int memberIndex)
{
if (memberIndex >= playerCountsList.Count)
{
return 0;
}
return playerCountsList[memberIndex];
}
public override void CheckIfInitializedAndValid()
{
}
private void UpdateMemberAttribute(string inKey, string inValue)
{
if (CurrentLobbyModification != null)
{
Debug.LogFormat("Setting lobby member attribute {0} to value {1} for user {2}", inKey, inValue, EOSLoginManager.loggedInProductId);
LobbyModificationRemoveMemberAttributeOptions lobbyModificationRemoveMemberAttributeOptions = default(LobbyModificationRemoveMemberAttributeOptions);
lobbyModificationRemoveMemberAttributeOptions.Key = inKey;
LobbyModificationRemoveMemberAttributeOptions options = lobbyModificationRemoveMemberAttributeOptions;
CurrentLobbyModification.RemoveMemberAttribute(ref options);
LobbyModificationAddMemberAttributeOptions lobbyModificationAddMemberAttributeOptions = default(LobbyModificationAddMemberAttributeOptions);
lobbyModificationAddMemberAttributeOptions.Attribute = new AttributeData
{
Key = inKey,
Value = inValue
};
lobbyModificationAddMemberAttributeOptions.Visibility = LobbyAttributeVisibility.Public;
LobbyModificationAddMemberAttributeOptions options2 = lobbyModificationAddMemberAttributeOptions;
CurrentLobbyModification.AddMemberAttribute(ref options2);
UpdateLobby(CurrentLobbyModification);
}
}
private void UpdatePlayerCount()
{
if (currentLobbyDetails != null)
{
int count = LocalUserManager.readOnlyLocalUsersList.Count;
ref MemoizedToString<int, ToStringImplementationInvariant> reference = ref localPlayerCountToString;
int input = Math.Max(1, count);
string @string = reference.GetString(in input);
LobbyDetailsCopyMemberAttributeByKeyOptions lobbyDetailsCopyMemberAttributeByKeyOptions = default(LobbyDetailsCopyMemberAttributeByKeyOptions);
lobbyDetailsCopyMemberAttributeByKeyOptions.AttrKey = "player_count";
lobbyDetailsCopyMemberAttributeByKeyOptions.TargetUserId = EOSLoginManager.loggedInProductId;
LobbyDetailsCopyMemberAttributeByKeyOptions options = lobbyDetailsCopyMemberAttributeByKeyOptions;
if (CurrentLobbyDetails.CopyMemberAttributeByKey(ref options, out var outAttribute) == Result.Success)
{
if ((string)outAttribute.Value.Data.Value.Value.AsUtf8 != @string && CurrentLobbyModification != null)
{
UpdateMemberAttribute("player_count", @string);
}
}
else
{
UpdateMemberAttribute("player_count", @string);
}
playerCountsList.Clear();
calculatedTotalPlayerCount = 0;
remoteMachineCount = 0;
calculatedExtraPlayersCount = 0;
ProductUserId loggedInProductId = EOSLoginManager.loggedInProductId;
LobbyDetailsGetMemberCountOptions options2 = default(LobbyDetailsGetMemberCountOptions);
uint memberCount = currentLobbyDetails.GetMemberCount(ref options2);
for (uint num = 0u; num < memberCount; num++)
{
LobbyDetailsGetMemberByIndexOptions lobbyDetailsGetMemberByIndexOptions = default(LobbyDetailsGetMemberByIndexOptions);
lobbyDetailsGetMemberByIndexOptions.MemberIndex = num;
LobbyDetailsGetMemberByIndexOptions options3 = lobbyDetailsGetMemberByIndexOptions;
ProductUserId memberByIndex = currentLobbyDetails.GetMemberByIndex(ref options3);
int result = 1;
LobbyDetailsCopyMemberAttributeByKeyOptions options4 = new LobbyDetailsCopyMemberAttributeByKeyOptions
{
AttrKey = "player_count",
TargetUserId = EOSLoginManager.loggedInProductId
};
if (CurrentLobbyDetails.CopyMemberAttributeByKey(ref options4, out var outAttribute2) == Result.Success)
{
result = ((!TextSerialization.TryParseInvariant((string)outAttribute2.Value.Data.Value.Value.AsUtf8, out result)) ? 1 : Math.Max(1, result));
}
if (memberByIndex == loggedInProductId)
{
result = Math.Max(1, count);
}
else
{
input = remoteMachineCount + 1;
remoteMachineCount = input;
}
playerCountsList.Add(result);
calculatedTotalPlayerCount += result;
if (result > 1)
{
calculatedExtraPlayersCount += result - 1;
}
}
}
onPlayerCountUpdated?.Invoke();
}
private void OnLobbyChanged()
{
OnLobbyDataUpdated();
onLobbyChanged?.Invoke();
(PlatformSystems.userManager as UserManagerEOS).QueryForDisplayNames(GetLobbyMembers());
}
public override void CreateLobby()
{
CreateLobbyOptions createLobbyOptions = default(CreateLobbyOptions);
createLobbyOptions.LocalUserId = EOSLoginManager.loggedInProductId;
createLobbyOptions.MaxLobbyMembers = (uint)RoR2Application.maxPlayers;
createLobbyOptions.PermissionLevel = ((preferredLobbyType != LobbyType.Public) ? LobbyPermissionLevel.Joinviapresence : LobbyPermissionLevel.Publicadvertised);
createLobbyOptions.BucketId = "gbx_internal";
createLobbyOptions.PresenceEnabled = true;
createLobbyOptions.AllowInvites = true;
CreateLobbyOptions options = createLobbyOptions;
base.awaitingCreate = true;
lobbyInterface?.CreateLobby(ref options, null, OnLobbyCreated);
}
public override void JoinLobby(PlatformID uid)
{
LeaveLobby(delegate
{
JoinLobbyOptions joinLobbyOptions = default(JoinLobbyOptions);
joinLobbyOptions.LocalUserId = EOSLoginManager.loggedInProductId;
JoinLobbyOptions options = joinLobbyOptions;
lobbyInterface?.JoinLobby(ref options, null, OnLobbyJoined);
});
base.awaitingJoin = true;
}
public void JoinLobby(LobbyDetails lobbyID)
{
LeaveLobby(delegate
{
JoinLobbyOptions joinLobbyOptions = default(JoinLobbyOptions);
joinLobbyOptions.LocalUserId = EOSLoginManager.loggedInProductId;
joinLobbyOptions.LobbyDetailsHandle = lobbyID;
JoinLobbyOptions options = joinLobbyOptions;
lobbyInterface?.JoinLobby(ref options, null, OnLobbyJoined);
});
base.awaitingJoin = true;
}
public void FindClipboardLobby(string lobbyId)
{
if (joinClipboardLobbySearchHandle != null)
{
joinClipboardLobbySearchHandle.Release();
joinClipboardLobbySearchHandle = null;
}
joinClipboardLobbySearchHandle = new LobbySearch();
CreateLobbySearchOptions createLobbySearchOptions = default(CreateLobbySearchOptions);
createLobbySearchOptions.MaxResults = 1u;
CreateLobbySearchOptions options = createLobbySearchOptions;
if (lobbyInterface?.CreateLobbySearch(ref options, out joinClipboardLobbySearchHandle) == Result.Success)
{
LobbySearchSetLobbyIdOptions lobbySearchSetLobbyIdOptions = default(LobbySearchSetLobbyIdOptions);
lobbySearchSetLobbyIdOptions.LobbyId = lobbyId;
LobbySearchSetLobbyIdOptions options2 = lobbySearchSetLobbyIdOptions;
joinClipboardLobbySearchHandle.SetLobbyId(ref options2);
LobbySearchFindOptions lobbySearchFindOptions = default(LobbySearchFindOptions);
lobbySearchFindOptions.LocalUserId = EOSLoginManager.loggedInProductId;
LobbySearchFindOptions options3 = lobbySearchFindOptions;
joinClipboardLobbySearchHandle.Find(ref options3, "ClipboardJoin", OnLobbySearchComplete);
}
}
public override void LeaveLobby()
{
LeaveLobbyOptions leaveLobbyOptions = default(LeaveLobbyOptions);
leaveLobbyOptions.LocalUserId = EOSLoginManager.loggedInProductId;
leaveLobbyOptions.LobbyId = currentLobbyId;
LeaveLobbyOptions options = leaveLobbyOptions;
lobbyInterface?.LeaveLobby(ref options, null, OnLobbyLeave);
currentLobbyId = string.Empty;
}
private void LeaveLobby(Action callback)
{
LeaveLobbyOptions leaveLobbyOptions = default(LeaveLobbyOptions);
leaveLobbyOptions.LocalUserId = EOSLoginManager.loggedInProductId;
leaveLobbyOptions.LobbyId = currentLobbyId;
LeaveLobbyOptions options = leaveLobbyOptions;
lobbyInterface?.LeaveLobby(ref options, null, delegate(ref LeaveLobbyCallbackInfo data)
{
OnLobbyLeave(ref data);
callback?.Invoke();
});
currentLobbyId = string.Empty;
}
public override PlatformID[] GetLobbyMembers()
{
LobbyDetailsGetMemberCountOptions options = default(LobbyDetailsGetMemberCountOptions);
uint? num = CurrentLobbyDetails?.GetMemberCount(ref options);
PlatformID[] array = null;
if (num.HasValue)
{
array = new PlatformID[num.Value];
for (uint num2 = 0u; num2 < array.Length; num2++)
{
LobbyDetailsGetMemberByIndexOptions lobbyDetailsGetMemberByIndexOptions = default(LobbyDetailsGetMemberByIndexOptions);
lobbyDetailsGetMemberByIndexOptions.MemberIndex = num2;
LobbyDetailsGetMemberByIndexOptions options2 = lobbyDetailsGetMemberByIndexOptions;
array[num2] = new PlatformID(CurrentLobbyDetails.GetMemberByIndex(ref options2));
}
}
return array;
}
public override bool ShouldShowPromoteButton()
{
return false;
}
private void Update()
{
if (startingFadeSet != (newestLobbyData.starting && !ClientScene.ready))
{
if (startingFadeSet)
{
FadeToBlackManager.fadeCount--;
}
else
{
FadeToBlackManager.fadeCount++;
}
startingFadeSet = !startingFadeSet;
}
}
private void StaticUpdate()
{
UpdateOwnsLobby();
}
private PlatformID GetLaunchParamsLobbyId()
{
string[] commandLineArgs = Environment.GetCommandLineArgs();
for (int i = 0; i < commandLineArgs.Length - 1; i++)
{
if (string.Equals(commandLineArgs[i], "+connect_lobby", StringComparison.OrdinalIgnoreCase) && PlatformID.TryParse(ArrayUtils.GetSafe(commandLineArgs, i + 1, in string.Empty), out var result))
{
return result;
}
}
return PlatformID.nil;
}
public void ForceLobbyDataUpdate()
{
}
public void SendLobbyMessage(LobbyMessageType messageType, NetworkWriter writer)
{
byte[] array = new byte[1 + writer.Position];
array[0] = (byte)messageType;
Array.Copy(writer.AsArray(), 0, array, 1, writer.Position);
}
public override void OnCutoffTimerComplete()
{
}
private void OnChatMessageReceived(ulong senderId, byte[] buffer, int byteCount)
{
try
{
NetworkReader networkReader = new NetworkReader(buffer);
if (byteCount >= 1)
{
LobbyMessageType lobbyMessageType = (LobbyMessageType)networkReader.ReadByte();
Debug.LogFormat("Received Steamworks Lobby Message from {0} ({1}B). messageType={2}", senderId, byteCount, lobbyMessageType);
switch (lobbyMessageType)
{
}
}
else
{
Debug.LogWarningFormat("Received SteamworksLobbyMessage from {0}, but the message was empty.");
}
}
catch (Exception message)
{
Debug.LogError(message);
}
}
private void OnLobbyCreated(ref CreateLobbyCallbackInfo data)
{
base.awaitingCreate = false;
if (data.ResultCode == Result.Success)
{
currentLobbyId = data.LobbyId;
TryGetLobbyDetails();
OnLobbyChanged();
}
}
protected void OnLobbyDataUpdated()
{
UpdateNewestLobbyData();
UpdateOwnsLobby();
UpdatePlayerCount();
if (currentLobbyDetails != null && !ownsLobby)
{
if (newestLobbyData.serverId.isValid)
{
bool num = newestLobbyData.serverId == NetworkManagerSystem.singleton.serverP2PId || NetworkManagerSystem.singleton.IsConnectedToServer(newestLobbyData.serverId);
bool flag = string.CompareOrdinal(RoR2Application.GetBuildId(), newestLobbyData.buildId) == 0;
if (!num && flag)
{
NetworkManagerSystem.singleton.desiredHost = new HostDescription(newestLobbyData.serverId, HostDescription.HostType.EOS);
lastHostingLobbyId = currentLobbyId;
}
}
else if (lastHostingLobbyId == currentLobbyId)
{
Debug.LogFormat("Intercepting bad or out-of-order lobby update to server id.");
}
else
{
NetworkManagerSystem.singleton.desiredHost = HostDescription.none;
}
}
onLobbyDataUpdated?.Invoke();
}
private void UpdateNewestLobbyData()
{
DateTime value = Util.UnixTimeStampToDateTimeUtc((uint)Util.GetCurrentUnixEpochTimeInSeconds()) + TimeSpan.FromSeconds(30.0);
if (currentLobbyDetails != null)
{
LobbyDataSetupState lobbyDataSetupState = new LobbyDataSetupState
{
totalMaxPlayers = RoR2Application.maxPlayers,
totalPlayerCount = calculatedTotalPlayerCount,
quickplayQueued = false,
starting = GetLobbyBoolValue(currentLobbyDetails, "starting"),
buildId = GetLobbyStringValue(currentLobbyDetails, "build_id"),
quickplayCutoffTime = value,
shouldConnect = false,
joinable = (calculatedTotalPlayerCount < RoR2Application.maxPlayers)
};
string lobbyStringValue = GetLobbyStringValue(currentLobbyDetails, "server_id");
if (lobbyStringValue != string.Empty)
{
lobbyDataSetupState.serverId = new PlatformID(lobbyStringValue);
}
newestLobbyData = new LobbyData(lobbyDataSetupState);
}
else
{
newestLobbyData = new LobbyData();
}
}
private void OnLobbyJoined(ref JoinLobbyCallbackInfo data)
{
base.awaitingJoin = false;
bool flag = data.ResultCode == Result.Success;
if (flag)
{
currentLobbyId = data.LobbyId;
TryGetLobbyDetails();
if (currentLobbyDetails != null)
{
string buildId = RoR2Application.GetBuildId();
string lobbyStringValue = GetLobbyStringValue(currentLobbyDetails, "build_id");
if (buildId != lobbyStringValue)
{
Debug.LogFormat("Lobby build_id mismatch, leaving lobby. Ours=\"{0}\" Theirs=\"{1}\"", buildId, lobbyStringValue);
SimpleDialogBox simpleDialogBox = SimpleDialogBox.Create();
simpleDialogBox.AddCancelButton(CommonLanguageTokens.ok);
simpleDialogBox.headerToken = new SimpleDialogBox.TokenParamsPair
{
token = "STEAM_LOBBY_VERSION_MISMATCH_DIALOG_TITLE",
formatParams = Array.Empty<object>()
};
SimpleDialogBox.TokenParamsPair descriptionToken = new SimpleDialogBox.TokenParamsPair
{
token = "STEAM_LOBBY_VERSION_MISMATCH_DIALOG_DESCRIPTION"
};
object[] formatParams = new string[2] { buildId, lobbyStringValue };
descriptionToken.formatParams = formatParams;
simpleDialogBox.descriptionToken = descriptionToken;
return;
}
}
Debug.LogFormat("lobby join succeeded. Lobby id = {0}", currentLobbyId);
OnLobbyChanged();
}
else
{
SimpleDialogBox simpleDialogBox2 = SimpleDialogBox.Create();
simpleDialogBox2.AddCancelButton(CommonLanguageTokens.ok);
simpleDialogBox2.headerToken = new SimpleDialogBox.TokenParamsPair
{
token = "EOS_CANNOT_JOIN_STEAM_LOBBY_HEADER",
formatParams = Array.Empty<object>()
};
simpleDialogBox2.descriptionToken = new SimpleDialogBox.TokenParamsPair
{
token = "KICK_REASON_SERVERFULL",
formatParams = Array.Empty<object>()
};
Console.instance.SubmitCmd(null, "steam_lobby_create_if_none", recordSubmit: true);
}
onLobbyJoined?.Invoke(flag);
}
private void OnLobbyMemberDataUpdated(PlatformID memberId)
{
UpdateOwnsLobby();
onLobbyMemberDataUpdated?.Invoke(memberId);
}
private void OnLobbyKicked(bool kickedDueToDisconnect, ulong lobbyId, ulong adminId)
{
Debug.LogFormat("Kicked from lobby. kickedDueToDisconnect={0} lobbyId={1} adminId={2}", kickedDueToDisconnect, lobbyId, adminId);
OnLobbyChanged();
}
private void OnLobbyLeave(ref LeaveLobbyCallbackInfo data)
{
Debug.LogFormat("Left lobby {0}.", data.LobbyId);
currentLobbyId = string.Empty;
if (currentLobbyDetails != null)
{
currentLobbyDetails.Release();
currentLobbyDetails = null;
}
if (currentLobbyModificationHandle != null)
{
currentLobbyModificationHandle.Release();
currentLobbyModificationHandle = null;
}
OnLobbyChanged();
}
private void OnLobbyJoinRequested(ulong lobbyId)
{
Debug.LogFormat("Request to join lobby {0} received. Attempting to join lobby.", lobbyId);
}
private void OnUserInvitedToLobby(ref LobbyInviteReceivedCallbackInfo data)
{
Debug.LogFormat("Received invitation to lobby {0} from sender {1}.", data.InviteId, data.TargetUserId);
}
private static void OnSendInviteComplete(ref SendInviteCallbackInfo data)
{
_ = data.GetResultCode() == Result.Success;
}
private void OnLobbySearchComplete(ref LobbySearchFindCallbackInfo data)
{
if (data.GetResultCode() != Result.Success)
{
return;
}
bool flag = data.ClientData as string == "ClipboardJoin";
List<LobbyDetails> list = new List<LobbyDetails>();
LobbySearch lobbySearch = (flag ? joinClipboardLobbySearchHandle : currentSearchHandle);
if (lobbySearch != null)
{
LobbySearchGetSearchResultCountOptions options = default(LobbySearchGetSearchResultCountOptions);
uint searchResultCount = lobbySearch.GetSearchResultCount(ref options);
for (uint num = 0u; num < searchResultCount; num++)
{
LobbyDetails outLobbyDetailsHandle = new LobbyDetails();
LobbySearchCopySearchResultByIndexOptions lobbySearchCopySearchResultByIndexOptions = default(LobbySearchCopySearchResultByIndexOptions);
lobbySearchCopySearchResultByIndexOptions.LobbyIndex = num;
LobbySearchCopySearchResultByIndexOptions options2 = lobbySearchCopySearchResultByIndexOptions;
if (lobbySearch.CopySearchResultByIndex(ref options2, out outLobbyDetailsHandle) == Result.Success)
{
if (flag)
{
JoinLobby(outLobbyDetailsHandle);
joinClipboardLobbySearchHandle.Release();
joinClipboardLobbySearchHandle = null;
return;
}
list.Add(outLobbyDetailsHandle);
}
}
}
(data.ClientData as Action<List<LobbyDetails>>)(list);
}
private void OnLobbyDataUpdateReceived(ref LobbyUpdateReceivedCallbackInfo data)
{
if (data.LobbyId == (Utf8String)currentLobbyId)
{
TryGetLobbyDetails();
OnLobbyChanged();
}
}
private void OnJoinLobbyAccepted(ref JoinLobbyAcceptedCallbackInfo data)
{
Debug.LogFormat("Attempting to join from ui event {0} from local user {1}.", data.UiEventId, data.LocalUserId);
LobbyDetails outLobbyDetailsHandle = new LobbyDetails();
CopyLobbyDetailsHandleByUiEventIdOptions copyLobbyDetailsHandleByUiEventIdOptions = default(CopyLobbyDetailsHandleByUiEventIdOptions);
copyLobbyDetailsHandleByUiEventIdOptions.UiEventId = data.UiEventId;
CopyLobbyDetailsHandleByUiEventIdOptions options = copyLobbyDetailsHandleByUiEventIdOptions;
Result? result = lobbyInterface?.CopyLobbyDetailsHandleByUiEventId(ref options, out outLobbyDetailsHandle);
if (result == Result.Success)
{
JoinLobby(outLobbyDetailsHandle);
}
else
{
Debug.LogFormat("failed getting lobby details from join callback, result = " + result.ToString());
}
}
private void OnLobbyInviteAccepted(ref LobbyInviteAcceptedCallbackInfo data)
{
Debug.LogFormat("Accepted invitation to lobby {0} from sender {1}.", data.InviteId, data.TargetUserId);
LobbyDetails outLobbyDetailsHandle = new LobbyDetails();
CopyLobbyDetailsHandleByInviteIdOptions copyLobbyDetailsHandleByInviteIdOptions = default(CopyLobbyDetailsHandleByInviteIdOptions);
copyLobbyDetailsHandleByInviteIdOptions.InviteId = data.InviteId;
CopyLobbyDetailsHandleByInviteIdOptions options = copyLobbyDetailsHandleByInviteIdOptions;
Result? result = lobbyInterface?.CopyLobbyDetailsHandleByInviteId(ref options, out outLobbyDetailsHandle);
if (result == Result.Success)
{
JoinLobby(outLobbyDetailsHandle);
}
else
{
Debug.LogFormat("failed getting lobby details from invite, result = " + result.ToString());
}
}
private void OnShowFriendsComplete(ref ShowFriendsCallbackInfo data)
{
_ = data.GetResultCode() == Result.Success;
}
private void OnLobbyUpdated(ref UpdateLobbyCallbackInfo data)
{
if (data.GetResultCode() == Result.Success)
{
OnLobbyChanged();
}
}
private void TryGetLobbyDetails()
{
if (currentLobbyDetails != null)
{
currentLobbyDetails.Release();
currentLobbyDetails = null;
}
CopyLobbyDetailsHandleOptions copyLobbyDetailsHandleOptions = default(CopyLobbyDetailsHandleOptions);
copyLobbyDetailsHandleOptions.LobbyId = currentLobbyId;
copyLobbyDetailsHandleOptions.LocalUserId = EOSLoginManager.loggedInProductId;
CopyLobbyDetailsHandleOptions options = copyLobbyDetailsHandleOptions;
_ = lobbyInterface?.CopyLobbyDetailsHandle(ref options, out currentLobbyDetails) == Result.Success;
TryGetLobbyModificationHandle();
}
private void TryGetLobbyModificationHandle()
{
if (currentLobbyModificationHandle != null)
{
currentLobbyModificationHandle.Release();
currentLobbyModificationHandle = null;
}
UpdateLobbyModificationOptions updateLobbyModificationOptions = default(UpdateLobbyModificationOptions);
updateLobbyModificationOptions.LobbyId = currentLobbyId;
updateLobbyModificationOptions.LocalUserId = EOSLoginManager.loggedInProductId;
UpdateLobbyModificationOptions options = updateLobbyModificationOptions;
_ = lobbyInterface?.UpdateLobbyModification(ref options, out currentLobbyModificationHandle) == Result.Success;
}
public bool RequestLobbyList(object requester, Filter filter, Action<List<LobbyDetails>> callback)
{
if (requester != null)
{
foreach (LobbyRefreshRequest lobbyRefreshRequest2 in lobbyRefreshRequests)
{
if (requester == lobbyRefreshRequest2.requester)
{
return false;
}
}
}
LobbyRefreshRequest lobbyRefreshRequest = default(LobbyRefreshRequest);
lobbyRefreshRequest.requester = requester;
lobbyRefreshRequest.filter = filter;
lobbyRefreshRequest.callback = callback;
LobbyRefreshRequest item = lobbyRefreshRequest;
lobbyRefreshRequests.Enqueue(item);
UpdateRefreshRequestQueue();
return true;
}
private void UpdateRefreshRequestQueue()
{
if (!currentRefreshRequest.HasValue && lobbyRefreshRequests.Count != 0)
{
SearchForLobbiesWithRequest(lobbyRefreshRequests.Dequeue());
}
}
private void SearchForLobbiesWithRequest(LobbyRefreshRequest request)
{
if (currentSearchHandle != null)
{
currentSearchHandle.Release();
currentSearchHandle = null;
}
CreateLobbySearchOptions createLobbySearchOptions = default(CreateLobbySearchOptions);
createLobbySearchOptions.MaxResults = 50u;
CreateLobbySearchOptions options = createLobbySearchOptions;
currentSearchHandle = new LobbySearch();
Result? result = lobbyInterface?.CreateLobbySearch(ref options, out currentSearchHandle);
if (result == Result.Success)
{
LobbySearchSetParameterOptions lobbySearchSetParameterOptions = default(LobbySearchSetParameterOptions);
lobbySearchSetParameterOptions.ComparisonOp = ComparisonOp.Equal;
lobbySearchSetParameterOptions.Parameter = new AttributeData
{
Key = "build_id",
Value = RoR2Application.GetBuildId()
};
LobbySearchSetParameterOptions options2 = lobbySearchSetParameterOptions;
currentSearchHandle.SetParameter(ref options2);
foreach (AttributeData searchDatum in request.filter.SearchData)
{
lobbySearchSetParameterOptions = default(LobbySearchSetParameterOptions);
lobbySearchSetParameterOptions.ComparisonOp = ComparisonOp.Equal;
lobbySearchSetParameterOptions.Parameter = searchDatum;
options2 = lobbySearchSetParameterOptions;
currentSearchHandle.SetParameter(ref options2);
}
LobbySearchFindOptions lobbySearchFindOptions = default(LobbySearchFindOptions);
lobbySearchFindOptions.LocalUserId = EOSLoginManager.loggedInProductId;
LobbySearchFindOptions options3 = lobbySearchFindOptions;
currentSearchHandle.Find(ref options3, request.callback, OnLobbySearchComplete);
}
else
{
Debug.LogError("Error Creating Lobby Search Handle! " + result.ToString());
}
}
private void OnStopClient()
{
NetworkConnection connection = NetworkManagerSystem.singleton.client.connection;
bool flag = false;
bool flag2 = Util.ConnectionIsLocal(connection);
flag = ((!(connection is EOSNetworkConnection)) ? (connection.address == newestLobbyData.serverAddressPortPair.address) : (((EOSNetworkConnection)connection).RemoteUserID == newestLobbyData.serverId.productUserID));
if (flag2 && ownsLobby && currentLobbyModificationHandle != null)
{
LobbyModificationRemoveAttributeOptions lobbyModificationRemoveAttributeOptions = default(LobbyModificationRemoveAttributeOptions);
lobbyModificationRemoveAttributeOptions.Key = "server_id";
LobbyModificationRemoveAttributeOptions options = lobbyModificationRemoveAttributeOptions;
currentLobbyModificationHandle.RemoveAttribute(ref options);
}
if (!flag2 && flag)
{
LeaveLobby();
}
}
private void OnStartHostingServer()
{
hostingServer = true;
}
private void OnStopHostingServer()
{
hostingServer = false;
}
public void JoinOrStartMigrate(PlatformID newLobbyId)
{
if (ownsLobby)
{
StartMigrateLobby(newLobbyId.productUserID);
}
else
{
JoinLobby(newLobbyId);
}
}
public void StartMigrateLobby(ProductUserId newLobbyId)
{
}
private void AttemptToJoinPendingSteamworksLobby()
{
_ = LocalUserManager.isAnyUserSignedIn;
}
public void SetLobbyQuickPlayQueuedIfOwner(bool quickplayQueuedState)
{
}
public void SetLobbyQuickPlayCutoffTimeIfOwner(uint? timestamp)
{
}
public void SetStartingIfOwner(bool startingState)
{
}
protected void OnLobbyOwnershipGained()
{
onLobbyOwnershipGained?.Invoke();
}
private void OnLobbyOwnershipLost()
{
onLobbyOwnershipLost?.Invoke();
}
public override bool IsLobbyOwner(PlatformID user)
{
LobbyDetailsGetLobbyOwnerOptions options = default(LobbyDetailsGetLobbyOwnerOptions);
if (currentLobbyDetails != null)
{
return currentLobbyDetails.GetLobbyOwner(ref options) == user.productUserID;
}
return false;
}
public override void AutoMatchmake()
{
}
public override bool IsLobbyOwner()
{
if (isInLobby)
{
return _ownsLobby;
}
return false;
}
public override bool CanInvite()
{
return !IsBusy;
}
public override void OpenInviteOverlay()
{
UIInterface uIInterface = EOSPlatformManager.GetPlatformInterface().GetUIInterface();
ShowFriendsOptions options = new ShowFriendsOptions
{
LocalUserId = EOSLoginManager.loggedInAuthId
};
uIInterface?.ShowFriends(ref options, null, OnShowFriendsComplete);
}
public override void OnStartPrivateGame()
{
}
public override void ToggleQuickplay()
{
}
public override void CheckIfInvited()
{
}
public override void CheckBusyTimer()
{
}
public override bool ShouldEnableQuickplayButton()
{
return false;
}
public override bool ShouldEnableStartPrivateGameButton()
{
return true;
}
public override string GetUserDisplayName(PlatformID user)
{
if (user.productUserID != null)
{
string userDisplayName = (PlatformSystems.userManager as UserManagerEOS).GetUserDisplayName(user);
if (userDisplayName != string.Empty)
{
return userDisplayName;
}
}
return "";
}
public string GetUserDisplayNameFromProductIdString(string productIdString, Action callback = null)
{
if (productIdString != string.Empty)
{
string userDisplayName = (PlatformSystems.userManager as UserManagerEOS).GetUserDisplayName(new PlatformID(productIdString), callback);
if (userDisplayName != string.Empty)
{
return userDisplayName;
}
}
return "";
}
private static LobbyType PermissionLevelToType(LobbyPermissionLevel permissionLevel)
{
return permissionLevel switch
{
LobbyPermissionLevel.Inviteonly => LobbyType.Private,
LobbyPermissionLevel.Publicadvertised => LobbyType.Public,
LobbyPermissionLevel.Joinviapresence => LobbyType.FriendsOnly,
_ => LobbyType.Error,
};
}
private static LobbyPermissionLevel LobbyTypeToPermissionLevel(LobbyType type)
{
return type switch
{
LobbyType.FriendsOnly => LobbyPermissionLevel.Joinviapresence,
LobbyType.Private => LobbyPermissionLevel.Joinviapresence,
LobbyType.Public => LobbyPermissionLevel.Publicadvertised,
_ => LobbyPermissionLevel.Joinviapresence,
};
}
public override string GetLobbyID()
{
return currentLobbyId;
}
public override bool CheckLobbyIdValidity(string lobbyID)
{
if (lobbyID.IndexOfAny(charactersToCheck) == -1)
{
return false;
}
return true;
}
public override void JoinLobby(ConCommandArgs args)
{
CheckIfInitializedAndValid();
string text = args[0];
Debug.LogFormat("Enqueuing join for lobby {0}...", text);
FindClipboardLobby(text);
}
public override void LobbyCreate(ConCommandArgs args)
{
EOSLobbyManager obj = PlatformSystems.lobbyManager as EOSLobbyManager;
obj.CheckIfInitializedAndValid();
if (!LocalUserManager.isAnyUserSignedIn)
{
throw new ConCommandException("Cannot create a Steamworks lobby without any local users signed in.");
}
obj.CreateLobby();
}
public override void LobbyCreateIfNone(ConCommandArgs args)
{
EOSLobbyManager obj = PlatformSystems.lobbyManager as EOSLobbyManager;
obj.CheckIfInitializedAndValid();
if (!LocalUserManager.isAnyUserSignedIn)
{
throw new ConCommandException("Cannot create a Steamworks lobby without any local users signed in.");
}
obj.CreateLobby();
}
public override void LobbyLeave(ConCommandArgs args)
{
EOSLobbyManager obj = PlatformSystems.lobbyManager as EOSLobbyManager;
obj.CheckIfInitializedAndValid();
obj.LeaveLobby();
}
public override void LobbyAssignOwner(ConCommandArgs args)
{
(PlatformSystems.lobbyManager as EOSLobbyManager).CheckIfInitializedAndValid();
Debug.LogFormat("Promoting {0} to lobby leader...", args[0]);
}
public override void LobbyInvite(ConCommandArgs args)
{
EOSLobbyManager eOSLobbyManager = PlatformSystems.lobbyManager as EOSLobbyManager;
eOSLobbyManager.CheckIfInitializedAndValid();
SendInviteOptions sendInviteOptions = default(SendInviteOptions);
sendInviteOptions.LobbyId = eOSLobbyManager.currentLobbyId;
sendInviteOptions.LocalUserId = EOSLoginManager.loggedInProductId;
sendInviteOptions.TargetUserId = ProductUserId.FromString(args.GetArgString(0));
SendInviteOptions options = sendInviteOptions;
eOSLobbyManager.lobbyInterface?.SendInvite(ref options, null, OnSendInviteComplete);
}
public override void LobbyOpenInviteOverlay(ConCommandArgs args)
{
if (EOSLoginManager.loggedInAuthId == null)
{
SteamworksLobbyManager.DoSteamLobbyOpenOverlay();
return;
}
EOSLobbyManager obj = PlatformSystems.lobbyManager as EOSLobbyManager;
obj.CheckIfInitializedAndValid();
obj.OpenInviteOverlay();
}
public override void LobbyCopyToClipboard(ConCommandArgs args)
{
EOSLobbyManager obj = PlatformSystems.lobbyManager as EOSLobbyManager;
obj.CheckIfInitializedAndValid();
GUIUtility.systemCopyBuffer = obj.currentLobbyId;
Chat.AddMessage(Language.GetString("STEAM_COPY_LOBBY_TO_CLIPBOARD_MESSAGE"));
}
public override void LobbyPrintData(ConCommandArgs args)
{
(PlatformSystems.lobbyManager as EOSLobbyManager).CheckIfInitializedAndValid();
new List<string>();
}
public override void DisplayId(ConCommandArgs args)
{
(PlatformSystems.lobbyManager as EOSLobbyManager).CheckIfInitializedAndValid();
}
public override void DisplayLobbyId(ConCommandArgs args)
{
(PlatformSystems.lobbyManager as EOSLobbyManager).CheckIfInitializedAndValid();
}
public override void LobbyPrintMembers(ConCommandArgs args)
{
(PlatformSystems.lobbyManager as EOSLobbyManager).CheckIfInitializedAndValid();
}
public override void ClearLobbies(ConCommandArgs args)
{
EOSLobbyManager obj = PlatformSystems.lobbyManager as EOSLobbyManager;
Filter filter = new Filter();
obj.RequestLobbyList(null, filter, delegate(List<LobbyDetails> lobbies)
{
foreach (LobbyDetails lobby in lobbies)
{
_ = lobby;
}
});
}
public override void LobbyUpdatePlayerCount(ConCommandArgs args)
{
(PlatformSystems.lobbyManager as EOSLobbyManager).UpdatePlayerCount();
}
public override void LobbyForceUpdateData(ConCommandArgs args)
{
EOSLobbyManager obj = PlatformSystems.lobbyManager as EOSLobbyManager;
obj.CheckIfInitializedAndValid();
obj.ForceLobbyDataUpdate();
}
public override void LobbyPrintList(ConCommandArgs args)
{
(PlatformSystems.lobbyManager as EOSLobbyManager).CheckIfInitializedAndValid();
}
public static bool IsLobbyOwner(LobbyDetails lobby)
{
LobbyDetailsGetLobbyOwnerOptions options = default(LobbyDetailsGetLobbyOwnerOptions);
return lobby.GetLobbyOwner(ref options) == EOSLoginManager.loggedInProductId;
}
public static string GetLobbyStringValue(LobbyDetails lobby, string key)
{
LobbyDetailsCopyAttributeByKeyOptions lobbyDetailsCopyAttributeByKeyOptions = default(LobbyDetailsCopyAttributeByKeyOptions);
lobbyDetailsCopyAttributeByKeyOptions.AttrKey = key;
LobbyDetailsCopyAttributeByKeyOptions options = lobbyDetailsCopyAttributeByKeyOptions;
if (lobby.CopyAttributeByKey(ref options, out var outAttribute) == Result.Success)
{
return outAttribute.Value.Data.Value.Value.AsUtf8;
}
return string.Empty;
}
public static bool GetLobbyBoolValue(LobbyDetails lobbyDetails, string key)
{
LobbyDetailsCopyAttributeByKeyOptions lobbyDetailsCopyAttributeByKeyOptions = default(LobbyDetailsCopyAttributeByKeyOptions);
lobbyDetailsCopyAttributeByKeyOptions.AttrKey = key;
LobbyDetailsCopyAttributeByKeyOptions options = lobbyDetailsCopyAttributeByKeyOptions;
if (lobbyDetails.CopyAttributeByKey(ref options, out var outAttribute) == Result.Success)
{
if (outAttribute.Value.Data.Value.Value.AsBool.HasValue)
{
return outAttribute.Value.Data.Value.Value.AsBool.Value;
}
return false;
}
return false;
}
public static long GetLobbyIntValue(LobbyDetails lobbyDetails, string key)
{
LobbyDetailsCopyAttributeByKeyOptions lobbyDetailsCopyAttributeByKeyOptions = default(LobbyDetailsCopyAttributeByKeyOptions);
lobbyDetailsCopyAttributeByKeyOptions.AttrKey = key;
LobbyDetailsCopyAttributeByKeyOptions options = lobbyDetailsCopyAttributeByKeyOptions;
if (lobbyDetails.CopyAttributeByKey(ref options, out var outAttribute) == Result.Success && outAttribute.Value.Data.Value.Value.AsInt64.HasValue)
{
return outAttribute.Value.Data.Value.Value.AsInt64.Value;
}
return 0L;
}
public static double GetLobbyDoubleValue(LobbyDetails lobbyDetails, string key)
{
LobbyDetailsCopyAttributeByKeyOptions lobbyDetailsCopyAttributeByKeyOptions = default(LobbyDetailsCopyAttributeByKeyOptions);
lobbyDetailsCopyAttributeByKeyOptions.AttrKey = key;
LobbyDetailsCopyAttributeByKeyOptions options = lobbyDetailsCopyAttributeByKeyOptions;
if (lobbyDetails.CopyAttributeByKey(ref options, out var outAttribute) == Result.Success && outAttribute.Value.Data.Value.Value.AsDouble.HasValue)
{
return outAttribute.Value.Data.Value.Value.AsDouble.Value;
}
return 0.0;
}
public static bool SetLobbyStringValue(LobbyModification lobby, string key, string value)
{
if (lobby == null || key == null || value == null || key == string.Empty || value == string.Empty)
{
return false;
}
LobbyModificationAddAttributeOptions lobbyModificationAddAttributeOptions = default(LobbyModificationAddAttributeOptions);
lobbyModificationAddAttributeOptions.Attribute = new AttributeData
{
Key = key,
Value = value
};
lobbyModificationAddAttributeOptions.Visibility = LobbyAttributeVisibility.Public;
LobbyModificationAddAttributeOptions options = lobbyModificationAddAttributeOptions;
return lobby.AddAttribute(ref options) == Result.Success;
}
public static void UpdateLobby(LobbyModification lobby)
{
EOSLobbyManager eOSLobbyManager = PlatformSystems.lobbyManager as EOSLobbyManager;
eOSLobbyManager.CheckIfInitializedAndValid();
UpdateLobbyOptions updateLobbyOptions = default(UpdateLobbyOptions);
updateLobbyOptions.LobbyModificationHandle = lobby;
UpdateLobbyOptions options = updateLobbyOptions;
eOSLobbyManager.lobbyInterface?.UpdateLobby(ref options, null, eOSLobbyManager.OnLobbyUpdated);
}
public static bool RemoveLobbyStringValue(LobbyModification lobby, string key)
{
if (lobby != null)
{
LobbyModificationRemoveAttributeOptions lobbyModificationRemoveAttributeOptions = default(LobbyModificationRemoveAttributeOptions);
lobbyModificationRemoveAttributeOptions.Key = key;
LobbyModificationRemoveAttributeOptions options = lobbyModificationRemoveAttributeOptions;
return lobby.RemoveAttribute(ref options) == Result.Success;
}
return false;
}
public static uint GetAllCurrentLobbyKVPs(LobbyDetails lobby, ref Dictionary<string, string> KVPs)
{
LobbyDetailsGetAttributeCountOptions options = default(LobbyDetailsGetAttributeCountOptions);
uint attributeCount = lobby.GetAttributeCount(ref options);
uint num = 0u;
for (uint num2 = attributeCount; num < num2; num++)
{
LobbyDetailsCopyAttributeByIndexOptions lobbyDetailsCopyAttributeByIndexOptions = default(LobbyDetailsCopyAttributeByIndexOptions);
lobbyDetailsCopyAttributeByIndexOptions.AttrIndex = num;
LobbyDetailsCopyAttributeByIndexOptions options2 = lobbyDetailsCopyAttributeByIndexOptions;
if (lobby.CopyAttributeByIndex(ref options2, out var outAttribute) == Result.Success)
{
AttributeData value = outAttribute.Value.Data.Value;
KVPs.Add(value.Key, value.Value.AsUtf8);
}
}
return attributeCount;
}
public override void SetLobbyTypeConVarString(string newValue)
{
EOSLobbyManager eOSLobbyManager = PlatformSystems.lobbyManager as EOSLobbyManager;
eOSLobbyManager.CheckIfInitializedAndValid();
LobbyDetailsCopyInfoOptions options = default(LobbyDetailsCopyInfoOptions);
if (eOSLobbyManager.CurrentLobbyDetails.CopyInfo(ref options, out var _) != 0 || !eOSLobbyManager.IsLobbyOwner())
{
throw new ConCommandException("Lobby type cannot be set while not the owner of a valid lobby.");
}
LobbyType dest = LobbyType.Error;
SteamLobbyTypeConVar.instance.GetEnumValueAbstract(newValue, ref dest);
if (dest == LobbyType.Error)
{
throw new ConCommandException("Lobby type \"Error\" is not allowed.");
}
LobbyModificationSetPermissionLevelOptions lobbyModificationSetPermissionLevelOptions = default(LobbyModificationSetPermissionLevelOptions);
lobbyModificationSetPermissionLevelOptions.PermissionLevel = LobbyTypeToPermissionLevel(dest);
LobbyModificationSetPermissionLevelOptions options2 = lobbyModificationSetPermissionLevelOptions;
if (eOSLobbyManager.CurrentLobbyModification.SetPermissionLevel(ref options2) == Result.Success)
{
UpdateLobby(eOSLobbyManager.CurrentLobbyModification);
}
}
public override string GetLobbyTypeConVarString()
{
EOSLobbyManager eOSLobbyManager = PlatformSystems.lobbyManager as EOSLobbyManager;
eOSLobbyManager.CheckIfInitializedAndValid();
if (eOSLobbyManager.currentLobbyDetails != null)
{
LobbyDetailsCopyInfoOptions options = default(LobbyDetailsCopyInfoOptions);
if (eOSLobbyManager.CurrentLobbyDetails.CopyInfo(ref options, out var outLobbyDetailsInfo) == Result.Success)
{
return PermissionLevelToType(outLobbyDetailsInfo.Value.PermissionLevel).ToString();
}
return string.Empty;
}
return string.Empty;
}
public override int GetLobbyMemberCount()
{
return 0;
}
}