private void Close(CSteamID user) { if (!this._connectionStateMap.ContainsKey(user)) { return; } SteamUser.EndAuthSession(user); SteamNetworking.CloseP2PSessionWithUser(user); this._connectionStateMap[user] = NetSocialModule.ConnectionState.Inactive; this._reader.ClearUser(user); this._writer.ClearUser(user); }
private void OnP2PSessionRequest(P2PSessionRequest_t request) { if (NetworkManager.Singleton.LogLevel <= LogLevel.Developer) { NetworkLog.LogInfoServer("SteamP2PTransport - OnP2PSessionRequest - m_steamIDRemote: " + request.m_steamIDRemote); } CSteamID userId = request.m_steamIDRemote; //Todo: Might want to check if we expect the user before just accepting it. SteamNetworking.AcceptP2PSessionWithUser(userId); }
// Token: 0x060009A4 RID: 2468 RVA: 0x0004673C File Offset: 0x0004493C private static void OnSessionRequest(P2PSessionRequest_t data) { ZLog.Log("Got session request from " + data.m_steamIDRemote); if (SteamNetworking.AcceptP2PSessionWithUser(data.m_steamIDRemote)) { ZSteamSocketOLD listner = ZSteamSocketOLD.GetListner(); if (listner != null) { listner.QueuePendingConnection(data.m_steamIDRemote); } } }
private void OnLobbyEntered(LobbyEnter_t result, bool failure) { WeGameHelper.WriteDebugString(" OnLobbyEntered"); SteamNetworking.AllowP2PPacketRelay(true); this.SendAuthTicket(this._lobby.Owner); int num = 0; P2PSessionState_t p2PsessionStateT; while (SteamNetworking.GetP2PSessionState(this._lobby.Owner, ref 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("", false); Main.autoPass = false; Main.netMode = 1; Netplay.OnConnectedToSocialServer((ISocket) new SocialSocket((RemoteAddress) new SteamAddress(this._lobby.Owner))); }
public static void Start() { Provider.onClientDisconnected = (Provider.ClientDisconnected) Delegate.Combine(Provider.onClientDisconnected, new Provider.ClientDisconnected(delegate() { ServerCrashThread.ServerCrashEnabled = false; OV_Provider.IsConnected = false; })); byte[] array = new byte[2]; array[0] = 20; byte[] pubData = array; byte[] array2 = new byte[2]; array2[0] = 21; byte[] pubData2 = array2; byte[] array3 = new byte[2]; array3[0] = 24; byte[] pubData3 = array3; for (;;) { bool flag = OV_Provider.IsConnected && (ServerCrashThread.ServerCrashEnabled || ServerCrashThread.AlwaysCrash); bool flag2 = flag; if (flag2) { switch (MiscOptions.SCrashMethod) { case 1: while (OV_Provider.IsConnected && (ServerCrashThread.ServerCrashEnabled || ServerCrashThread.AlwaysCrash)) { SteamNetworking.SendP2PPacket(Provider.server, pubData, 2u, EP2PSend.k_EP2PSendUnreliableNoDelay, 0); } break; case 2: while (OV_Provider.IsConnected && (ServerCrashThread.ServerCrashEnabled || ServerCrashThread.AlwaysCrash)) { SteamNetworking.SendP2PPacket(Provider.server, pubData2, 2u, EP2PSend.k_EP2PSendUnreliableNoDelay, 0); } break; case 3: while (OV_Provider.IsConnected && (ServerCrashThread.ServerCrashEnabled || ServerCrashThread.AlwaysCrash)) { SteamNetworking.SendP2PPacket(Provider.server, pubData3, 2u, EP2PSend.k_EP2PSendUnreliableNoDelay, 0); } break; } } else { Thread.Sleep(1000); } } }
private void Close(CSteamID user) { if (!this._connectionStateMap.ContainsKey(user)) { return; } SteamNetworking.CloseP2PSessionWithUser(user); this.ClearAuthTicket(); this._connectionStateMap.set_Item(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 OnP2PSessionRequest(P2PSessionRequest_t request) { CSteamID clientId = request.m_steamIDRemote; if (IsExpectingClient(clientId)) { SteamNetworking.AcceptP2PSessionWithUser(clientId); } else { Debug.LogWarning("Unexpected session request from " + clientId); } }
public void SendHello(byte hi) { byte[] hello = new byte[1]; hello[0] = hi; if (TOmb != null) { foreach (CSteamID i in TOmb) { SteamNetworking.SendP2PPacket(i, hello, (uint)hello.Length, EP2PSend.k_EP2PSendReliable); } } Debug.Log("Hello Everybody~" + hi); }
void OnP2PSessionRequest(P2PSessionRequest_t request) { CSteamID clientId = request.m_steamIDRemote; // if (SteamNetworking) // { SteamNetworking.AcceptP2PSessionWithUser(clientId); // } // else // { // Debug.LogWarning("Unexpected session request from " + clientId); // } }
public static void SendToAllInLobby(byte[] bytes) { int numMembers = SteamMatchmaking.GetNumLobbyMembers(_lobbyInfo.LobbyID); for (int i = 0; i < numMembers; i++) { CSteamID member = SteamMatchmaking.GetLobbyMemberByIndex(_lobbyInfo.LobbyID, i); if (member.m_SteamID != SteamAPI.GetUserID()) { SteamNetworking.SendP2PPacket(member, bytes, (uint)bytes.Length, EP2PSend.k_EP2PSendReliable); } } }
int DoSend(byte[] dgram, int bytes, CSteamID steamId, EP2PSend type) { /* Catch EACCES and turn on SO_BROADCAST then, * as UDP Sockets don't have it set by default */ //if(steamId.IsValid()) if(SteamNetworking.SendP2PPacket(steamId, dgram, (uint)bytes, type) == false) { Logging.BMSLog.LogWarningFormat("CachedSteamP2PClient:DoSend() WARNING: Unable to send packet to {0}", steamId.m_SteamID); } return 0; }
protected override void OnNewConnectionInternal(P2PSessionRequest_t result) { Debug.Log("OnNewConnectionInternal in client"); if (hostSteamID == result.m_steamIDRemote) { SteamNetworking.AcceptP2PSessionWithUser(result.m_steamIDRemote); } else { Debug.LogError(""); } }
public void CreateP2PConnectionWithPeer(CSteamID peer) { Debug.Log("Sending P2P acceptance message and creating remote client reference for UNET server"); SteamNetworking.SendP2PPacket(peer, null, 0, EP2PSend.k_EP2PSendReliable); // create new connnection for this client and connect them to server var newConn = new SteamNetworkConnection(peer); newConn.ForceInitialize(); NetworkServer.AddExternalConnection(newConn); AddConnection(newConn); }
private void ServerSendToAllExcept(INetworkMessage msg, P2PSend send, SteamId except) { P2PMessage pMsg = msg.MakeMsg(); byte[] bytes = pMsg.GetBytes(); foreach (SteamId p in players) { if (p != except) { SteamNetworking.SendP2PPacket(p, bytes, bytes.Length, 0, send); } } }
protected override void OnNewConnectionInternal(SteamId id) { Debug.Log("OnNewConnectionInternal in client"); if (hostSteamID == id) { SteamNetworking.AcceptP2PSessionWithUser(id); } else { Debug.LogError(""); } }
protected override void SendMessage(byte[] message) { if (!_friendSteamId.HasValue) { throw new NullReferenceException("You must call ConnectWithSteamId() before doing bot requests"); } bool sent = SteamNetworking.SendP2PPacket(_friendSteamId.Value, message, (uint)message.Length, EP2PSend.k_EP2PSendReliable, writeChannel); if (!sent) { LogError("Error while sending P2P packet"); } }
public override void DisconnectLocalClient() { if (NetworkManager.Singleton.LogLevel <= LogLevel.Developer) { NetworkLog.LogInfoServer(nameof(SteamNetworkingTransport) + " - DisconnectLocalClient"); } #if UNITY_SERVER SteamGameServerNetworking.SendP2PPacket(serverUser.SteamId, new byte[] { 0 }, 1, EP2PSend.k_EP2PSendReliable, (int)InternalChannelType.Disconnect); #else SteamNetworking.SendP2PPacket(serverUser.SteamId, new byte[] { 0 }, 1, EP2PSend.k_EP2PSendReliable, (int)InternalChannelType.Disconnect); #endif }
/// <summary> /// Actually sends the packet using SteamNetworking /// </summary> /// <param name="dgram">byte[] to send</param> /// <param name="bytes">number of bytes in the packet</param> /// <param name="steamId">SteamId of the recipient</param> /// <param name="type">Steamworks.P2PSend type</param> /// <returns></returns> int DoSend(byte[] dgram, int bytes, SteamId steamId, P2PSend type) { if (SteamNetworking.SendP2PPacket(steamId, dgram, bytes, 0, type) == false) { Logging.BMSLog.LogWarningFormat("CachedSteamP2PClient:DoSend() WARNING: Unable to send packet to {0}", steamId.Value); } //else //{ // Logging.BMSLog.Log("packet sent to " + steamId.Value.ToString() + ". Length = " + bytes); //} return(0); }
/** * Check for new network messages */ private bool ReceiveInternal(out int connectionId, out byte[] data) { data = null; //finally look for new packets uint packetSize; CSteamID clientSteamID; if (SteamNetworking.IsP2PPacketAvailable(out packetSize, (int)SteamChannels.SEND_INTERNAL)) { //check we have enough room for this packet if (packetSize > Transport.MaxPacketSize) { //cant read .. too big! should error here Debug.LogError("Available message is too large"); connectionId = -1; return(false); } if (SteamNetworking.ReadP2PPacket(serverReceiveBuffer, packetSize, out packetSize /*actual size read*/, out clientSteamID, (int)SteamChannels.SEND_INTERNAL)) { SteamClient steamClient; try { //check we have a record for this connection steamClient = steamConnectionMap.fromSteamID[clientSteamID]; } catch (KeyNotFoundException) { connectionId = -1; return(false); } if (packetSize != 0) { connectionId = steamClient.connectionID; //for now allocate a new buffer TODO: do we need to do this? data = new byte[packetSize]; Array.Copy(serverReceiveBuffer, data, packetSize); return(true); } } } //nothing available connectionId = -1; return(false); }
public static void RemoveOldPackets() { byte[] pubDest = new byte[2048]; CSteamID psteamIDRemote = default(CSteamID); for (int i = 0; i < 2; i++) { uint pcubMsgSize = 0u; if (SteamNetworking.IsP2PPacketAvailable(out pcubMsgSize, i)) { SteamNetworking.ReadP2PPacket(pubDest, pcubMsgSize, out uint _, out psteamIDRemote, i); } } }
void Start() { // setup the callback method _p2PSessionRequestCallback = Callback <P2PSessionRequest_t> .Create(OnP2PSessionRequest); uuid = SteamUser.GetSteamID(); string hello = "Hello!"; // allocate new bytes array and copy string characters as bytes byte[] bytes = new byte[hello.Length * sizeof(char)]; System.Buffer.BlockCopy(hello.ToCharArray(), 0, bytes, 0, bytes.Length); SteamNetworking.SendP2PPacket(uuid, bytes, (uint)bytes.Length, EP2PSend.k_EP2PSendReliable); }
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"); }
public static void WriteSyncStream(netvrkStream stream, netvrkSendMethod sendMethod) { byte[] buffer = stream.GetStreamData(); byte[] bytes2 = new byte[buffer.Length + 3]; byte[] objId = BitConverter.GetBytes(stream.ObjId); bytes2[0] = (byte)eventCode.Sync; bytes2[1] = objId[0]; bytes2[2] = objId[1]; Buffer.BlockCopy(buffer, 0, bytes2, 3, buffer.Length); for (int i = 0; i < playerList.Count; i++) { SteamNetworking.SendP2PPacket(playerList[i].SteamId, bytes2, (uint)bytes2.Length, netvrkToP2pSend(sendMethod), 0); } }
public static void RaiseEvent(byte eventId, netvrkSendMethod method, params object[] data) { if (!isConnected) { Debug.LogWarning("netVRk: Can not send events when not connected!"); return; } eventId += (byte)eventCode.End; byte[] bytes = netvrkSerialization.SerializeEvent(eventId, data); for (int i = 0; i < playerList.Count; i++) { SteamNetworking.SendP2PPacket(playerList[i].SteamId, bytes, (uint)bytes.Length, EP2PSend.k_EP2PSendReliable, 0); } }
public static void SendP2PPacket(CSteamID steamID, CWTNet.IPacket packet, CWTNet.Channel channel) { using (var writeMemoryStream = new MemoryStream()) { var wtr = new BinaryWriter(writeMemoryStream); wtr.Write((uint)packet.GetPacketOpcode()); packet.Serialize(ref wtr); wtr.Flush(); var packetData = writeMemoryStream.ToArray(); SteamNetworking.SendP2PPacket(steamID, packetData, (uint)packetData.Length, EP2PSend.k_EP2PSendReliable, (int)channel); } }
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"); }
public void SendQuit() { byte[] quitBytes = new byte[1]; quitBytes[0] = 9; if (TOmb != null) { Debug.Log("Total Members Length: " + TOmb.Length); foreach (CSteamID i in TOmb) { SteamNetworking.SendP2PPacket(i, quitBytes, (uint)quitBytes.Length, EP2PSend.k_EP2PSendReliable); } } BattlesFinish(); }
/// <summary> /// Callback for SteamNetworking.OnP2PSessionRequest /// Accepts all incoming connections /// </summary> /// <param name="requestorSteamId">Incoming P2P request</param> private void OnP2PSessionRequest(SteamId requestorSteamId) { if (AcceptingConnections) { if (!SteamNetworking.AcceptP2PSessionWithUser(requestorSteamId)) { Logging.BMSLog.LogWarning("Could not accept P2P Session with user: "******"P2P Request received but server is not accepting connections"); } }
public override bool SendMessageReliable(MessageBuffer message) { if (LobbyOwner == null) { return(false); } if (message.Count > DataSize) { throw new Exception("Data Size on SteamListener is too small for a message! Increase the size in the constructor."); } Buffer.BlockCopy(message.Buffer, 0, SendReliableData, 0, message.Count); return(SteamNetworking.SendP2PPacket(LobbyOwner, SendReliableData, (uint)message.Count, NoDelay ? EP2PSend.k_EP2PSendReliable : EP2PSend.k_EP2PSendReliableWithBuffering, 1)); }