public async Task <Lobby> CreateLobby(LobbyCreateParams createParams)
{
ELobbyType type;
switch (createParams.Type)
{
case LobbyType.Private: type = ELobbyType.k_ELobbyTypePrivate; break;
default:
case LobbyType.Public: type = ELobbyType.k_ELobbyTypePublic; break;
}
var size = createParams.Capacity;
var lobbyEnter = SteamUtility.WaitFor <LobbyEnter_t>();
var result = await SteamMatchmaking.CreateLobby(type, (int)size).ToTask <LobbyCreated_t>();
SteamUtility.ThrowIfError(result.m_eResult);
await lobbyEnter;
var lobbyId = new CSteamID(lobbyEnter.Result.m_ulSteamIDLobby);
var lobby = new SteamLobby(lobbyId, this);
if (createParams.Metadata != null)
{
foreach (var kvp in createParams.Metadata)
{
if (kvp.Key == null || kvp.Value == null)
{
continue;
}
SteamMatchmaking.SetLobbyData(lobbyId, kvp.Key, kvp.Value.ToString());
}
}
_connectedLobbies.Add(lobbyId, lobby);
return(lobby);
}
////////////////
/// Lobby Creation Methods and callbacks
///////////////
public void CreateLobby(ELobbyType lobbyType, int maxMembers)
{
SteamAPICall_t handle = SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePublic, maxMembers);
OnLobbyCreatedCallResult.Set(handle);
Debug.Log("SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePublic, 1) : " + handle);
}
private void updateLobbyPrivacy()
{
if (lobbyOwner != selfId)
{
return;
}
if (lobby != null)
{
GalaxyInstance.Matchmaking().SetLobbyType(lobby, privacyToLobbyType(privacy));
}
if (lobby == null)
{
if (steamLobby.HasValue)
{
SteamMatchmaking.LeaveLobby(steamLobby.Value);
}
}
else if (!steamLobby.HasValue)
{
if (steamLobbyEnterCallback == null)
{
steamLobbyEnterCallback = Callback <LobbyEnter_t> .Create(onSteamLobbyEnter);
}
SteamMatchmaking.CreateLobby(privacyToSteamLobbyType(privacy), (int)memberLimit);
}
else
{
SteamMatchmaking.SetLobbyType(steamLobby.Value, privacyToSteamLobbyType(privacy));
SteamMatchmaking.SetLobbyData(steamLobby.Value, "connect", getConnectionString());
}
}
// Token: 0x06002EDC RID: 11996 RVA: 0x00132248 File Offset: 0x00130648
public static void createLobby()
{
Terminal.print("Create lobby", null, Provider.STEAM_IC, Provider.STEAM_DC, true);
SteamAPICall_t hAPICall = SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePrivate, 24);
Lobbies.lobbyCreated.Set(hAPICall, null);
}
public void HostSingleLobby()
{
Debug.Log(networkManager.maxConnections);
connectionUI.SetActive(false);
networkManager.singlePlayerMode = true;
SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypeFriendsOnly, networkManager.maxConnections);
}
public void CreateLobby()
{
var mumber_count = 8;
var lobby_type = ELobbyType.k_ELobbyTypePublic;
CLobbyCreator.Set(SteamMatchmaking.CreateLobby(lobby_type, mumber_count), OnLobbyCreated);
}
public void CreateLobby()
{
if (SteamManager.Initialized)
{
SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypeFriendsOnly, MAX_PLAYERS);
}
}
// Update is called once per frame
void OnGUI()
{
SteamAPI.RunCallbacks();
if (GUI.Button(new Rect(120, 20, 140, 20), "Create Lobby"))
{
print("Create lobby");
SteamAPICall_t host = SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePublic, 4);
}
if (GUI.Button(new Rect(120, 20, 280, 20), "lobbies list"))
{
print("list lobbies");
SteamAPICall_t getList = SteamMatchmaking.RequestLobbyList();
}
if (GUI.Button(new Rect(120, 20, 420, 20), "change first lobby"))
{
print("change first lobby");
SteamAPICall_t joinLobby = SteamMatchmaking.JoinLobby(SteamMatchmaking.GetLobbyByIndex(0));
}
if (GUI.Button(new Rect(120, 20, 560, 20), "Num Players"))
{
int numPlayers = SteamMatchmaking.GetNumLobbyMembers((CSteamID)currentID);
print("Number of players" + numPlayers);
for (int i = 0; i < numPlayers; i++)
{
print("\t Player(" + i + ")==" + SteamFriends.GetFriendPersonaName(SteamMatchmaking.GetLobbyMemberByIndex((CSteamID)currentID, i)));
}
}
}
public static void CreateLobby(bool isPublic = false)
{
Debug.Log("Creating lobby");
SteamAPICall_t handle = SteamMatchmaking.CreateLobby(isPublic ? ELobbyType.k_ELobbyTypePublic : ELobbyType.k_ELobbyTypeFriendsOnly, 2);
SteamHelper.LobbyCreated.Set(handle);
}
public void HostGame()
{
if (lobby.Equals(CSteamID.Nil) == false)
{
Debug.LogError("Lobby already created. Probably already hosting. Must shut down hosting before doing it again.");
return;
}
//Construct the network database. Very important!
MeshNetworkIdentity databaseID = new MeshNetworkIdentity((ushort)ReservedObjectIDs.DatabaseObject,
(ushort)ReservedPrefabIDs.Database,
(ulong)GetLocalPlayerID(), true);
database = game.SpawnDatabase(databaseID).GetComponent <NetworkDatabase>(); //Spawns the database prefab.
Debug.Log("Registering database.");
database.AddObject(databaseID, true); //Tells the database that it itself exists (funny)
//First, we get our own player object, and we make ourselves the provider.
Player me = ConstructPlayer(SteamUser.GetSteamID());
Debug.Log("Registering provider.");
database.AddPlayer(me, true);
//Actually create the lobby. Password info, etc, will be set after this.
Debug.Log("Creating Lobby");
m_LobbyCreated.Set(SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePrivate, 4));
}
public static void createLobby()
{
Terminal.print("Create lobby", null, Provider.STEAM_IC, Provider.STEAM_DC, true);
SteamAPICall_t steamAPICall_t = SteamMatchmaking.CreateLobby(0, 24);
Lobbies.lobbyCreated.Set(steamAPICall_t, null);
}
public void Create(bool inviteOnly, CallResult <LobbyCreated_t> .APIDispatchDelegate callResult)
{
SteamAPICall_t steamAPICallT = SteamMatchmaking.CreateLobby((inviteOnly ? ELobbyType.k_ELobbyTypePrivate : ELobbyType.k_ELobbyTypeFriendsOnly), 256);
this._lobbyCreatedExternalCallback = callResult;
this._lobbyCreated.Set(steamAPICallT, null);
this.State = LobbyState.Creating;
}
public void CreateSteamFriendsLobby()
{
if (SteamManager.Initialized)
{
Debug.Log("[STEAM] Initializing lobby creation ... ");
SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypeFriendsOnly, _maxFriends);
}
}
public void CreateLobby()
{
Debug.Log("Creating lobby");
UNETServerController.inviteFriendOnStart = false;
SteamMatchmaking.CreateLobby(lobbyAccess, MAX_USERS);
// ...continued in OnLobbyEntered callback
}
public void Create(bool inviteOnly, CallResult <LobbyCreated_t> .APIDispatchDelegate callResult)
{
SteamAPICall_t hAPICall = SteamMatchmaking.CreateLobby((!inviteOnly) ? ELobbyType.k_ELobbyTypeFriendsOnly : ELobbyType.k_ELobbyTypePrivate, 17);
_lobbyCreatedExternalCallback = callResult;
_lobbyCreated.Set(hAPICall);
State = LobbyState.Creating;
}
public SteamAPICall_t createLobbyGameServer(ELobbyType ELobbyType)
{
SteamAPICall_t handle = SteamMatchmaking.CreateLobby(ELobbyType, 250);
OnLobbyCreatedCallResult.Set(handle);
Console.WriteLine("SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePublic, 1) : " + handle);
return(handle);
}
public void Create(bool inviteOnly, CallResult <LobbyCreated_t> .APIDispatchDelegate callResult)
{
SteamAPICall_t lobby = SteamMatchmaking.CreateLobby(inviteOnly ? (ELobbyType)0 : (ELobbyType)1, 256);
this._lobbyCreatedExternalCallback = callResult;
this._lobbyCreated.Set(lobby, (CallResult <LobbyCreated_t> .APIDispatchDelegate)null);
this.State = LobbyState.Creating;
}
public void HostLobby()
{
menuManager.NavigateToMenu("Loading");
try {
SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypeFriendsOnly, networkManager.maxConnections);
} catch (System.Exception e) {
menuManager.NavigateToMenu("Error", e.Message);
}
}
//Steam callback action
private void LobbySearch(LobbyMatchList_t callback)
{
//Create new lobby if none are open
if (callback.m_nLobbiesMatching <= 0)
{
SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePublic, networkManager.maxConnections);
}
//Only joins the first lobby found (so not truly random but whatever)
SteamMatchmaking.JoinLobby(SteamMatchmaking.GetLobbyByIndex(0));
}
public static void Create(string name, int memberLimit, bool friendsOnly, Action callback, Action callbackFail)
{
CoopLobbyManager.Initialize();
CoopLobbyManager.createCallback = callback;
CoopLobbyManager.createFailCallback = callbackFail;
CoopLobbyManager.createValues = new CoopLobbyInfo(0UL);
CoopLobbyManager.createValues.Name = name;
CoopLobbyManager.createValues.MemberLimit = memberLimit;
SteamMatchmaking.CreateLobby((!friendsOnly) ? ELobbyType.k_ELobbyTypePublic : ELobbyType.k_ELobbyTypeFriendsOnly, memberLimit);
}
public void Host(CSteamID selfSteamId, ELobbyType lobbyType, OnLobbyReady func = null)
{
if (Disposed)
{
throw new ObjectDisposedException("SteamP2PServer", "This object has been disposed and can not be used to connect, please use a new SteamP2PServer");
}
try
{
Client = new CachedSteamP2PClient(selfSteamId);
Me = new NetworkingPlayer(ServerPlayerCounter++, selfSteamId, true, this);
Me.InstanceGuid = InstanceGuid.ToString();
m_CallbackLobbyCreated = Callback <LobbyCreated_t> .Create((LobbyCreated_t data) =>
{
LobbyID = (CSteamID)data.m_ulSteamIDLobby;
if (func != null)
{
func();
}
});
m_CreateLobbyResult = SteamMatchmaking.CreateLobby(lobbyType, 5);
// Do any generic initialization in result of the successful bind
OnBindSuccessful();
// Create the thread that will be listening for new data from connected clients and start its execution
Task.Queue(ReadClients);
// Create the thread that will check for player timeouts
Task.Queue(() =>
{
commonServerLogic.CheckClientTimeout((player) =>
{
Disconnect(player, true);
OnPlayerTimeout(player);
CleanupDisconnections();
});
});
//Let myself know I connected successfully
OnPlayerConnected(Me);
// Set myself as a connected client
Me.Connected = true;
StartAcceptingConnections();
}
catch (Exception e)
{
Logging.BMSLog.LogException(e);
// Do any generic initialization in result of the binding failure
OnBindFailure();
throw new FailedBindingException("Failed to bind to host/port, see inner exception", e);
}
}
/////////////////////////////////////////////////////////////////////////////
// Join / Update / Entering Lobbies / Leaving Lobbies
public void CreateLobby()
{
SteamAPICall_t handle = SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePublic, 2);
OnLobbyCreatedCallResult.Set(handle);
if (DebugTextOn)
{
Debug.Log("SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePublic, 1) : " + handle);
}
}
public void Create(bool inviteOnly, APIDispatchDelegate <LobbyCreated_t> callResult)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
SteamAPICall_t val = SteamMatchmaking.CreateLobby((ELobbyType)((!inviteOnly) ? 1 : 0), 256);
_lobbyCreatedExternalCallback = callResult;
_lobbyCreated.Set(val, (APIDispatchDelegate <LobbyCreated_t>)null);
State = LobbyState.Creating;
}
public void HostLobby()
{
mainMenu.SetActive(false);
if (useSteam)
{
SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypeFriendsOnly, 4);
return;
}
NetworkManager.singleton.StartHost();
}
public static void CreateLobby(bool privateLobby)
{
if (isLobbyConnected())
{
return;
}
Logger.Debug($"Creating a lobby");
SteamAPICall_t handle = SteamMatchmaking.CreateLobby(privateLobby ? ELobbyType.k_ELobbyTypeFriendsOnly : ELobbyType.k_ELobbyTypePublic, Config.Instance.MaxLobbySize);
OnLobbyCreatedCallResult.Set(handle);
}
// Token: 0x06000968 RID: 2408 RVA: 0x000453B0 File Offset: 0x000435B0
public void RegisterServer(string name, bool password, string version, bool publicServer, string worldName)
{
this.UnregisterServer();
SteamAPICall_t hAPICall = SteamMatchmaking.CreateLobby(publicServer ? ELobbyType.k_ELobbyTypePublic : ELobbyType.k_ELobbyTypeFriendsOnly, 32);
this.m_lobbyCreated.Set(hAPICall, null);
this.m_registerServerName = name;
this.m_registerPassword = password;
this.m_registerVerson = version;
ZLog.Log("Registering lobby");
}
// Use this for initialization
void Start()
{
lobbyCreated = CallResult <LobbyCreated_t> .Create((cb, failure) =>
{
Debug.Log(failure);
Debug.Log(cb.m_eResult);
});
SteamAPICall_t call = SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePrivate, 4);
lobbyCreated.Set(call);
}
public void HostLobby()
{
landingPagePanel.SetActive(false);
if (useSteam)
{
SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypeFriendsOnly, 4); // friends only lobby, with max of 4 players
return;
}
NetworkManager.singleton.StartHost();
}
public override void OnMatchCreate(bool success, string extendedInfo, MatchInfo matchInfo)
{
base.OnMatchCreate(success, extendedInfo, matchInfo);
_currentMatchID = (System.UInt64)matchInfo.networkId;
SteamMatchmaking.SetUNETMatchID(matchInfo.networkId);
SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePublic, maxPlayers);
//SteamMatchmaking.SetLobbyData((CSteamID)result.m_ulSteamIDLobby, "name", matchNameInput.text);
//Debug.Log("UNET MATCH ID ------ " + _currentMatchID);
}
private void startLobby(LobbyType lobbyType)
{
ButtonsHolder.SetActive(false);
if (lobbyType == LobbyType.PRIVATE)
{
SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypeFriendsOnly, networkManager.maxConnections);
}
if (lobbyType == LobbyType.PUBLIC)
{
SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePublic, networkManager.maxConnections);
}
}