public unsafe static void CloseConnection(User who) { if (!_initialized) { return; } SteamNetworking.CloseP2PSessionWithUser(new CSteamID(who.id)); }
protected void CloseP2PSessionWithUser(CSteamID clientSteamID) { if (!SteamManager.Initialized) { throw new ObjectDisposedException("Steamworks"); } SteamNetworking.CloseP2PSessionWithUser(clientSteamID); }
protected void CloseP2PSessionWithUser(CSteamID clientSteamID) { #if UNITY_SERVER SteamGameServerNetworking.CloseP2PSessionWithUser(clientSteamID); #else SteamNetworking.CloseP2PSessionWithUser(clientSteamID); #endif }
protected void CloseP2PSessionWithUser(SteamId clientSteamID) { if (!Steamworks.SteamClient.IsValid) { throw new ObjectDisposedException("Steamworks"); } SteamNetworking.CloseP2PSessionWithUser(clientSteamID); }
private void OnLobbyEntered(LobbyEnter_t result, bool failure) { //IL_001e: Unknown result type (might be due to invalid IL or missing references) //IL_002c: Unknown result type (might be due to invalid IL or missing references) //IL_0082: Unknown result type (might be due to invalid IL or missing references) //IL_0094: Unknown result type (might be due to invalid IL or missing references) //IL_00a4: Unknown result type (might be due to invalid IL or missing references) //IL_00b2: Unknown result type (might be due to invalid IL or missing references) //IL_00ca: Unknown result type (might be due to invalid IL or missing references) //IL_00db: Unknown result type (might be due to invalid IL or missing references) //IL_0127: Unknown result type (might be due to invalid IL or missing references) WeGameHelper.WriteDebugString(" OnLobbyEntered"); SteamNetworking.AllowP2PPacketRelay(true); SendAuthTicket(_lobby.Owner); int num = 0; P2PSessionState_t val = default(P2PSessionState_t); while (SteamNetworking.GetP2PSessionState(_lobby.Owner, ref val) && val.m_bConnectionActive != 1) { switch (val.m_eP2PSessionError) { case 2: ClearAuthTicket(); return; case 1: ClearAuthTicket(); return; case 3: ClearAuthTicket(); return; case 5: ClearAuthTicket(); return; case 4: if (++num > 5) { ClearAuthTicket(); return; } SteamNetworking.CloseP2PSessionWithUser(_lobby.Owner); SendAuthTicket(_lobby.Owner); break; } } _connectionStateMap[_lobby.Owner] = ConnectionState.Connected; SteamFriends.SetPlayedWith(_lobby.Owner); SteamFriends.SetRichPresence("status", Language.GetTextValue("Social.StatusInGame")); Main.clrInput(); Netplay.ServerPassword = ""; Main.GetInputText(""); Main.autoPass = false; Main.netMode = 1; Netplay.OnConnectedToSocialServer(new SocialSocket(new SteamAddress(_lobby.Owner))); }
public override bool Disconnect() { CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(new CSteamID(LobbyID)); SteamMatchmaking.LeaveLobby(new CSteamID(LobbyID)); HandleDisconnection(); Connected = false; return(SteamNetworking.CloseP2PSessionWithUser(lobbyOwner)); }
public void Stop() { SteamNetworking.CloseP2PSessionWithUser(NetClient.instanceClient.serversSteamID); //if(client == null) //{ // return; //} //client.Dispose(); }
async Task WaitAndClose(CSteamID remote) { await Task.Delay(2000); if (SteamManager.Initialized) { SteamNetworking.CloseP2PSessionWithUser(remote); Debug.Log($"SteamConnection Closed {remote}"); } }
private void Close(CSteamID user) { if (!this._connectionStateMap.ContainsKey(user)) { return; } SteamUser.EndAuthSession(user); SteamNetworking.CloseP2PSessionWithUser(user); this._connectionStateMap[user] = NetSocialModule.ConnectionState.Inactive; }
private void OnLobbyEntered(LobbyEnter_t result, bool failure) { SteamNetworking.AllowP2PPacketRelay(true); this.SendAuthTicket(this._lobby.Owner); var num = 0; P2PSessionState_t p2PsessionStateT; while (SteamNetworking.GetP2PSessionState(this._lobby.Owner, out p2PsessionStateT) && p2PsessionStateT.m_bConnectionActive != 1) { switch ((byte)p2PsessionStateT.m_eP2PSessionError) { case 1: this.ClearAuthTicket(); return; case 2: this.ClearAuthTicket(); return; case 3: this.ClearAuthTicket(); return; case 4: if (++num > 5) { this.ClearAuthTicket(); return; } SteamNetworking.CloseP2PSessionWithUser(this._lobby.Owner); this.SendAuthTicket(this._lobby.Owner); continue; case 5: this.ClearAuthTicket(); return; default: continue; } } this._connectionStateMap[this._lobby.Owner] = NetSocialModule.ConnectionState.Connected; SteamFriends.SetPlayedWith(this._lobby.Owner); SteamFriends.SetRichPresence("status", Language.GetTextValue("Social.StatusInGame")); Main.clrInput(); Netplay.ServerPassword = ""; Main.GetInputText(""); Main.autoPass = false; Main.netMode = 1; Netplay.OnConnectedToSocialServer( (ISocket) new SocialSocket((RemoteAddress) new SteamAddress(this._lobby.Owner))); }
/** * This closes the P2P connection and if its connected or connecting adds it to a queue to return the disconnect event */ private void closeSteamConnection(SteamClient steamClient) { if (steamClient.state == SteamClient.ConnectionState.CONNECTED || steamClient.state == SteamClient.ConnectionState.CONNECTING) { steamClient.state = SteamClient.ConnectionState.DISCONNECTING; steamDisconnectedConnections.Enqueue(steamClient); } SteamNetworking.CloseP2PSessionWithUser(steamClient.steamID); }
public override void disconnect() { if (friend == null) { return; } Log.trace("Closed P2P session with " + friend.displayName); SteamNetworking.CloseP2PSessionWithUser(new CSteamID(friend.id)); friend = null; }
private void Close(CSteamID user) { if (_connectionStateMap.ContainsKey(user)) { SteamUser.EndAuthSession(user); SteamNetworking.CloseP2PSessionWithUser(user); _connectionStateMap[user] = ConnectionState.Inactive; _reader.ClearUser(user); _writer.ClearUser(user); } }
private void Close(CSteamID user) { if (_connectionStateMap.ContainsKey(user)) { SteamNetworking.CloseP2PSessionWithUser(user); ClearAuthTicket(); _connectionStateMap[user] = ConnectionState.Inactive; _lobby.Leave(); _reader.ClearUser(user); _writer.ClearUser(user); } }
private void Close(CSteamID user) { if (!this._connectionStateMap.ContainsKey(user)) { return; } SteamUser.EndAuthSession(user); SteamNetworking.CloseP2PSessionWithUser(user); this._connectionStateMap.set_Item(user, NetSocialModule.ConnectionState.Inactive); this._reader.ClearUser(user); this._writer.ClearUser(user); }
void RemoveConnection(CSteamID user) { int id; if (!connectionIds.TryGetValue(user, out id)) { return; } SteamNetworking.CloseP2PSessionWithUser(user); connectionIds.Remove(user); connectionUsers.Remove(id); }
private void Close(CSteamID user) { if (!this._connectionStateMap.ContainsKey(user)) { return; } SteamNetworking.CloseP2PSessionWithUser(user); this.ClearAuthTicket(); this._connectionStateMap[user] = NetSocialModule.ConnectionState.Inactive; this._lobby.Leave(); this._reader.ClearUser(user); this._writer.ClearUser(user); }
public void Stop() { //if(udpServer == null) //{ // return; //} //udpServer.Close(); //udpServer.Dispose(); foreach (NetworkPlayer player in NetServer.serverInstance.connections.ToArray()) { SteamNetworking.CloseP2PSessionWithUser(player.steamID); } }
private void CloseP2PSessions() { foreach (User user in connectedUsers.Values) { SteamNetworking.CloseP2PSessionWithUser(user.SteamId); } if (serverUser != null) { SteamNetworking.CloseP2PSessionWithUser(serverUser.SteamId); } connectedUsers.Clear(); serverUser = null; // if (LogHelper.CurrentLogLevel <= LogLevel.Developer) LogHelper.LogInfo("SteamP2PTransport - CloseP2PSessions - has Closed P2P Sessions With all Users"); }
private void CloseP2PSessions() { foreach (User user in connectedUsers.Values) { SteamNetworking.CloseP2PSessionWithUser(user.SteamId); } if (serverUser != null) { SteamNetworking.CloseP2PSessionWithUser(serverUser.SteamId); } connectedUsers.Clear(); serverUser = null; NetworkLog.LogInfoServer("SteamP2PTransport - CloseP2PSessions - has Closed P2P Sessions With all Users"); }
protected virtual void Dispose(bool disposing) { if (disposed) return; disposed = true; if (disposing) { //DISPOSE OF STEAM P2P SOCKET if (steamEndPoint.IsValid()) { SteamNetworking.CloseP2PSessionWithUser(steamEndPoint); } } }
public bool ClientGetNextMessage(out TransportEvent transportEvent, out byte[] data) { transportEvent = TransportEvent.Disconnected; data = null; //basic - Steam P2P doesnt have a real connection state if (steamClientServer == null || mode != Mode.CLIENT) { return(false); } if (steamClientServer.state == SteamClient.ConnectionState.DISCONNECTING) { if (LogFilter.Debug || debug) { Debug.Log("We are currently trying to disconnect - so, disconnect"); } transportEvent = TransportEvent.Disconnected; //make sure we dont communicate any more SteamNetworking.CloseP2PSessionWithUser(steamClientServer.steamID); //we are done being a client steamClientServer = null; mode = Mode.UNDEFINED; return(true); } if (steamClientServer.state == SteamClient.ConnectionState.CONNECTING && Time.time - clientConnectStarted > clientConnectTimeout) { Debug.LogWarning("Timeout while connecting.."); ClientDisconnect(); return(false); } //if we are not connecting or connected then we shouldnt get getting messages - exit here if (steamClientServer.state != SteamClient.ConnectionState.CONNECTED && steamClientServer.state != SteamClient.ConnectionState.CONNECTING) { return(false); } handleInternalMessages(); int connectionId; return(ReceiveAndProcessEvents(out connectionId, out transportEvent, out data, (int)SteamChannels.SEND_TO_CLIENT)); }
private void OnLobbyEntered(LobbyEnter_t result, bool failure) { SteamNetworking.AllowP2PPacketRelay(true); SendAuthTicket(_lobby.Owner); int num = 0; P2PSessionState_t pConnectionState; while (SteamNetworking.GetP2PSessionState(_lobby.Owner, out pConnectionState) && pConnectionState.m_bConnectionActive != 1) { switch (pConnectionState.m_eP2PSessionError) { case 2: ClearAuthTicket(); return; case 1: ClearAuthTicket(); return; case 3: ClearAuthTicket(); return; case 5: ClearAuthTicket(); return; case 4: if (++num > 5) { ClearAuthTicket(); return; } SteamNetworking.CloseP2PSessionWithUser(_lobby.Owner); SendAuthTicket(_lobby.Owner); break; } } _connectionStateMap[_lobby.Owner] = ConnectionState.Connected; SteamFriends.SetPlayedWith(_lobby.Owner); SteamFriends.SetRichPresence("status", "Playing online."); Main.clrInput(); Netplay.ServerPassword = ""; Main.GetInputText(""); Main.autoPass = false; Main.netMode = 1; Netplay.OnConnectedToSocialServer(new SocialSocket(new SteamAddress(_lobby.Owner))); }
public void LeaveLobby() { if (lobbyID.m_SteamID != 0) { SteamMatchmaking.LeaveLobby(lobbyID); } foreach (ulong player in otherPlayers) { SteamNetworking.CloseP2PSessionWithUser((CSteamID)player); } connectedPlayers.Clear(); otherPlayers.Clear(); lobbyID = new CSteamID(0); isInGame = false; }
void OnLobbyChatUpdate(LobbyChatUpdate_t pCallback) { if (pCallback.m_rgfChatMemberStateChange == (uint)EChatMemberStateChange.k_EChatMemberStateChangeLeft && pCallback.m_ulSteamIDLobby == steamLobbyId.m_SteamID) { Debug.Log("A client has disconnected from the UNET server"); // user left lobby var userId = new CSteamID(pCallback.m_ulSteamIDUserChanged); if (UNETServerController.IsHostingServer()) { UNETServerController.RemoveConnection(userId); } SteamNetworking.CloseP2PSessionWithUser(userId); } }
private void OnP2PSessionConnectFail(P2PSessionConnectFail_t callback) { if (P2PLogFilter.logError) { Debug.LogError(string.Format("[TransportLayerSteam] Connection error: {0} with steam user {1}", (EP2PSessionError)callback.m_eP2PSessionError, callback.m_steamIDRemote)); } if (callback.m_eP2PSessionError != 0) { SteamNetworking.CloseP2PSessionWithUser(callback.m_steamIDRemote); int item; if (this.m_Connections.TryGetValue(callback.m_steamIDRemote, out item)) { this.m_ConnectionsBrokenInternal.Push(item); } } }
protected override void Dispose(bool disposing) { base.Dispose(disposing); if (remoteSteamId != CSteamID.Nil) { SteamNetworking.CloseP2PSessionWithUser(remoteSteamId); if (SteamNetManager.singleton.steamIdToConnection != null) { SteamNetManager.singleton.steamIdToConnection.Remove(remoteSteamId); } remoteSteamId = CSteamID.Nil; } }
private void Close(CSteamID user) { //IL_0006: Unknown result type (might be due to invalid IL or missing references) //IL_000f: Unknown result type (might be due to invalid IL or missing references) //IL_0022: Unknown result type (might be due to invalid IL or missing references) //IL_003a: Unknown result type (might be due to invalid IL or missing references) //IL_0046: Unknown result type (might be due to invalid IL or missing references) if (_connectionStateMap.ContainsKey(user)) { SteamNetworking.CloseP2PSessionWithUser(user); ClearAuthTicket(); _connectionStateMap[user] = ConnectionState.Inactive; _lobby.Leave(); _reader.ClearUser(user); _writer.ClearUser(user); } }
private void CloseP2PSessions() { foreach (User user in connectedUsers.Values) { SteamNetworking.CloseP2PSessionWithUser(user.SteamId); } if (serverUser != null) { SteamNetworking.CloseP2PSessionWithUser(serverUser.SteamId); } connectedUsers.Clear(); serverUser = null; if (NetworkingManager.Singleton.LogLevel <= LogLevel.Developer) { UnityEngine.Debug.Log("SteamP2PTransport - CloseP2PSessions - has Closed P2P Sessions With all Users"); } }
void CloseAllConnections() { if (currentLobbyId == CSteamID.Nil) { return; } SteamMatchmaking.LeaveLobby(currentLobbyId); var playerCount = SteamMatchmaking.GetNumLobbyMembers(currentLobbyId); for (var i = 0; i < playerCount; i++) { var id = SteamMatchmaking.GetLobbyMemberByIndex(currentLobbyId, i); SteamNetworking.CloseP2PSessionWithUser(id); } Debug.Log($"[Steam] Left lobby {currentLobbyId}"); currentLobbyId = CSteamID.Nil; }