public static NetOutgoingMessage CreateClaimSquareMessage(NetPeer sender, Player player, int x, int y) { NetOutgoingMessage output = sender.CreateMessage(); output.Write(PacketType.ClaimSquare); output.Write(player.Name); output.Write(x); output.Write(y); return(output); }
/// <summary> /// Contacts the Master Server on the net and gets a list of available host games /// </summary> /// <param name="netPeer"></param> private static void GetServerList(NetPeer netPeer) { m_masterServer = new IPEndPoint(NetUtility.Resolve(masterServer), masterserverport); NetOutgoingMessage listRequest = netPeer.CreateMessage(); listRequest.Write((byte)1); listRequest.Write(netPeer.Configuration.AppIdentifier); netPeer.SendUnconnectedMessage(listRequest, m_masterServer); }
public void Send(NetPeer inSourcePeer, NetConnection inTargetConnection, NetDeliveryMethod inDeliveryMethod = NetDeliveryMethod.ReliableOrdered) { NetOutgoingMessage newMessage = inSourcePeer.CreateMessage(); newMessage.WriteVariableInt32((int)DataMessageType.Command); newMessage.WriteVariableInt32((int)type); dataAsPacket.PackInto(newMessage); NetworkManager.instance.Send(newMessage, inTargetConnection, inDeliveryMethod); }
public override void Start() { base.Start(); var approval = NetPeer.CreateMessage(); approval.Write("Approve me please, there might be token"); NetPeer.Connect(_options.ServerHost, _options.ServerPort, approval); Logger.LogInformation($"Send connection approval to {_options.ServerHost}:{_options.ServerPort}"); }
internal static void RequestIntroduction(NetPeer peer, Guid guid, IPEndPoint internalIp) { var request = peer.CreateMessage(); request.Write(NetworkSettings.GameAppId); request.Write(NetworkSettings.MasterServerPayload); request.Write((byte)MasterServerMessageType.RequestIntroduction); request.Write(guid.ToString()); request.Write(internalIp); peer.SendUnconnectedMessage(request, ResolveEndPoint()); }
static void Main(string[] args) { var config = new NetPeerConfiguration("MultiPlayer"); config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest); config.EnableMessageType(NetIncomingMessageType.ConnectionApproval); config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse); config.AcceptIncomingConnections = true; config.Port = 5002; var Me = new NetPeer(config); Me.Start(); Me.DiscoverLocalPeers(5001); while (true) { NetIncomingMessage message; while ((message = Me.ReadMessage()) != null) { switch (message.MessageType) { case NetIncomingMessageType.Data: Console.WriteLine(message.ReadString()); break; case NetIncomingMessageType.DiscoveryRequest: var response = Me.CreateMessage("Uuum hi..?"); Me.SendDiscoveryResponse(response, message.SenderEndPoint); Console.WriteLine($"Someone at {message.SenderEndPoint.Address} is attempting to discover us!"); break; case NetIncomingMessageType.DiscoveryResponse: Me.Connect(message.SenderEndPoint); Console.WriteLine($"Peer discovered at {message.SenderEndPoint.Address}. Attempting to connect."); //TODO connect? break; case NetIncomingMessageType.ConnectionApproval: message.SenderConnection.Approve(); Console.WriteLine($"Uuum. Someone connected. I don't really know what to do now..."); break; case NetIncomingMessageType.StatusChanged: Console.WriteLine(message.ReadString()); break; default: Console.WriteLine(message.ReadString()); break; } } } }
public static NetOutgoingMessage CreateConnectionApprovalMessage(NetPeer sender, IPEndPoint[] otherPeers) { NetOutgoingMessage output = sender.CreateMessage(); output.Write(otherPeers.Length); for (int i = 0; i < otherPeers.Length; i++) { output.Write(otherPeers[i]); } return(output); }
internal static void UnregisterHost(NetPeer peer, Guid guid) { var request = peer.CreateMessage(); request.Write(NetworkSettings.GameAppId); request.Write(NetworkSettings.MasterServerPayload); request.Write((byte)MasterServerMessageType.UnregisterHost); request.Write(guid.ToString()); peer.SendUnconnectedMessage(request, ResolveEndPoint()); Debug.WriteLine("Unregistering with master server (Guid: " + guid + ")"); }
/// <summary> /// Establish connection to port and host. /// </summary> /// <param name="type">The type of the system (only peer or client are supported).</param> /// <param name="host">The host. Example: 129.12.12.12</param> /// <param name="port">The port.</param> /// <returns>True if connection was succesfully opened.</returns> public bool OpenConnection(SysType type, string host, int port) { NetConnection connection = null; if (type == SysType.Peer) { // START FIRST! var hail = _netPeer.CreateMessage("OpenConnection"); connection = _netPeer.Connect(host, port, hail); } if (type == SysType.Client) { // START FIRST! var hail = _netClient.CreateMessage("OpenConnection"); connection = _netClient.Connect(host, port, hail); } return ((connection != null) && connection.Status == NetConnectionStatus.Connected); }
public void SendMessage(INetworkMessage msg, NetConnection recipient, bool guaranteed) { NetDeliveryMethod method = (guaranteed ? NetDeliveryMethod.ReliableOrdered : NetDeliveryMethod.UnreliableSequenced); // opt - tell the peer the message size NetOutgoingMessage outgoing = _peer.CreateMessage(); outgoing.Write((byte)msg.MessageType); msg.Encode(outgoing); _peer.SendMessage(outgoing, recipient, method); }
public Client(string ip, int port) { try { ecdhrsaProvider = new ECDHRSAProvider(); NetPeerConfiguration config = new NetPeerConfiguration("GJABD_GAME"); config.EnableUPnP = true; config.LocalAddress = IPAddress.Any; /* FOR PRODUCTION * config.PingInterval = 5f; * config.ConnectionTimeout = 10f; * config.ResendHandshakeInterval = 1f; * config.MaximumHandshakeAttempts = 2; */ netPeer = new NetPeer(config); netPeer.Start(); // needed for initialization Console.WriteLine("started peer"); NetOutgoingMessage sendMsg = netPeer.CreateMessage(); sendMsg.Write("RELEASE_GAME_WEB"); sendMsg.Write(ClientConstants.version.ToString()); //send authentication public key and verifications. SecureMessageEncoder sem = new SecureMessageEncoder(sendMsg); sem.WriteBytes(ecdhrsaProvider.GetECDHPublicKey()); sem.WriteBytes(ecdhrsaProvider.GetSignedHash()); sem.WriteBytes(ecdhrsaProvider.GetRSAPublicKey()); sendMsg = sem.PackAndGet(); IPEndPoint ipEnd = new IPEndPoint(IPAddress.Parse(ip), port); NetConnection connection = netPeer.Connect(ipEnd, sendMsg); Console.WriteLine("connected to server"); // in your separate thread while (netPeer.MessageReceivedEvent.WaitOne()) { NetIncomingMessage msg = netPeer.ReadMessage(); CMessageParseManager.parseMessage(msg, this); netPeer.Recycle(msg); Console.WriteLine("Unique identifier is " + NetUtility.ToHexString(netPeer.UniqueIdentifier)); } } catch (Exception e) { Console.WriteLine(e); } }
public void SendMessage(Message message, NetDeliveryMethod deliveryMethod, int sequenceChannel) { var outgoingMessage = netPeer.CreateMessage(); message.WritePayload(outgoingMessage); if (Key != null) { IsAuthenticated = true; //outgoingMessage.Encrypt(cryptoAlgorithm); } netPeer.SendMessage(outgoingMessage, Connections, deliveryMethod, sequenceChannel); //Trace.WriteLine("Sent " + ((CustomMessageType)message.MessageType).ToString() + "."); if (OnConnectedMessageSent != null) { OnConnectedMessageSent(this, new MessageEventArgs(this, message)); } }
private void InitializeServer() { _connection_type = INSTANCE_TYPE.SERVER_TYPE; NetPeerConfiguration config = new NetPeerConfiguration("ServerClientClient"); config.AcceptIncomingConnections = true; config.MaximumConnections = 2; config.Port = _server_port; config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse); _connection = new NetServer(config); Debug.Assert(_connection != null); _connection.Start(); NetIncomingMessage pInMsg; bool ready = false; Console.ForegroundColor = ConsoleColor.Gray; Console.WriteLine("\nServer Instance\nWaiting for clients...\n"); int count = 0; while (!ready) { if ((pInMsg = _connection.ReadMessage()) != null && pInMsg.MessageType == NetIncomingMessageType.StatusChanged) { if ((NetConnectionStatus)pInMsg.ReadByte() == NetConnectionStatus.Connected) { NetOutgoingMessage m = _connection.CreateMessage(); m.Write(_connection.ConnectionsCount); _connection.SendMessage(m, _connection.Connections[_connection.ConnectionsCount - 1], NetDeliveryMethod.ReliableOrdered); if (count != _connection.ConnectionsCount) { count = _connection.ConnectionsCount; Console.WriteLine("\nClients connected: " + count + "\n"); } if (_connection.ConnectionsCount >= 2) { ready = true; } } } } }
void Start() { MyNetwork = GetComponent <MyNetwork>(); NetPeerConfiguration config = new NetPeerConfiguration(appName); peer = new NetClient(config); peer.Start(); NetOutgoingMessage approval = peer.CreateMessage(); connection = peer.Connect("localhost", 3000, approval); }
public static bool Write(Identity target, byte[] data, ulong contentLength, SendMethod method, int channel, NetPeer host, Dictionary <ulong, NetConnection> peers) { if (!peers.ContainsKey(target)) { return(false); } NetDeliveryMethod deliveryMethod = NetDeliveryMethod.Unknown; switch (method) { case SendMethod.SEND_RELIABLE: deliveryMethod = NetDeliveryMethod.ReliableOrdered; break; case SendMethod.SEND_RELIABLE_WITH_BUFFERING: deliveryMethod = NetDeliveryMethod.ReliableUnordered; break; case SendMethod.SEND_UNRELIABLE: case SendMethod.SEND_UNRELIABLE_NO_DELAY: deliveryMethod = NetDeliveryMethod.Unreliable; break; } NetConnection p = peers[target.Serialize()]; int totalLength = (int)contentLength + sizeof(int); NetOutgoingMessage msg = host.CreateMessage(totalLength); byte[] chData = BitConverter.GetBytes(channel); foreach (byte t in chData) { msg.Write(t); } msg.Write(data, 0, (int)contentLength); var result = p.SendMessage(msg, deliveryMethod, 0); if (result != NetSendResult.Dropped && result != NetSendResult.FailedNotConnected) { return(true); } if (channel == 0 && (((EPacket)data[0]) == EPacket.REJECTED || ((EPacket)data[0]) == EPacket.KICKED)) { CloseConnection(target, peers); } LogUtils.LogError("Failed to deliver message: " + result); return(false); }
//TODO: do this in other places public void Send(Packet v, NetDeliveryMethod DeliveryType) { lock (Lock) { var Message = myPeer.CreateMessage(); mySendFormatter.Serialize(myStream, v); Message.Write(myStream.ToArray()); myPeer.SendMessage(Message, myServerConnection, DeliveryType); //TODO: tweak this so it works for game and update myStream.SetLength(0); myStream.Position = 0; } }
internal void WaitConnection(IPEndPoint waitingPoint) { ThrowIfDisposed(); int oldState = Interlocked.CompareExchange(ref _state, (int)PeerState.ConnectedToPeers, (int)PeerState.ConnectedToService); if (oldState == (int)PeerState.NotConnected) { throw new InvalidOperationException("Peer has not right state."); } // Создания и отправка сообщения для пробивания NAT, // и возможности принять входящее соединение var holePunchMessage = _handler.CreateMessage(); holePunchMessage.Write((byte)0); _handler.SendUnconnectedMessage(holePunchMessage, waitingPoint); DisconnectFromService(); ClientModel.Logger.WriteDebug("AsyncPeer.WaitConnection({0})", waitingPoint); }
internal void WaitConnection(IPEndPoint waitingPoint) { ThrowIfDisposed(); int oldState = Interlocked.CompareExchange(ref _state, (int)PeerState.ConnectedToPeers, (int)PeerState.ConnectedToService); if (oldState == (int)PeerState.NotConnected) { throw new InvalidOperationException("Peer has not right state."); } // Creating and sending message that be pierce NAT // and creates possibility accept incoming message var holePunchMessage = _handler.CreateMessage(); holePunchMessage.Write((byte)0); _handler.SendUnconnectedMessage(holePunchMessage, waitingPoint); DisconnectFromService(); _logger.WriteDebug("AsyncPeer.WaitConnection({0})", waitingPoint); }
protected virtual void HandleOnUnconnectedMessage(NetPeer peer, NetIncomingMessage message) { var packetType = message.ReadString(); switch (packetType) { case "status": var response = peer.CreateMessage(); response.WriteVariableInt32(peer.ConnectionsCount); peer.SendUnconnectedMessage(response, message.SenderEndPoint); break; } }
private NetOutgoingMessage BuildMessage(NetMessage message) { var packet = _netPeer.CreateMessage(4); if (!_strings.TryFindStringId(message.MsgName, out int msgId)) { throw new NetManagerException($"[NET] No string in table with name {message.MsgName}. Was it registered?"); } packet.Write((byte)msgId); message.WriteToBuffer(packet); return(packet); }
static void HostGame(HostOptions h) { Console.WriteLine("Hosting a new game"); DM = LoadEncounter(); Console.WriteLine("Loaded encounter"); var config = new NetPeerConfiguration("Shrinelands") { Port = Program.Port }; peer = new NetServer(config); peer.Start(); while (true) { NetIncomingMessage message; while ((message = peer.ReadMessage()) != null) { switch (message.MessageType) { case NetIncomingMessageType.Data: // handle custom messages var data = message.ReadString(); if (data == "Send DM") { Console.WriteLine("Sending DM to client"); string json = JsonConvert.SerializeObject(DM); var response = peer.CreateMessage("DM\n" + json); peer.SendMessage(response, message.SenderConnection, NetDeliveryMethod.ReliableOrdered); } break; case NetIncomingMessageType.StatusChanged: // handle connection status messages break; case NetIncomingMessageType.DebugMessage: // handle debug messages // (only received when compiled in DEBUG mode) Console.WriteLine(message.ReadString()); break; /* .. */ default: Console.WriteLine("unhandled message with type: " + message.MessageType); break; } } } }
protected Task <R> SendCommand <R>(string commandName) { var msg = _peer.CreateMessage(); var id = WriteCommand(msg, commandName); _peer.SendMessage(msg, _connection, NetDeliveryMethod.Unreliable); return(SubscribeToResponse <R>(id)); }
public NetOutgoingMessage GetMessage(NetPeer peer) { var msg = peer.CreateMessage(); try { msg.Write(this.Serialize()); } catch (Exception ex) { IGConsole.Log(ex); } return(msg); }
internal static void RegisterHost(NetPeer peer, Guid guid, IPEndPoint internalIp, NetworkSessionPublicInfo publicInfo) { var request = peer.CreateMessage(); request.Write(NetworkSettings.GameAppId); request.Write(NetworkSettings.MasterServerPayload); request.Write((byte)MasterServerMessageType.RegisterHost); request.Write(guid.ToString()); request.Write(internalIp); publicInfo.Pack(request); peer.SendUnconnectedMessage(request, ResolveEndPoint()); Debug.WriteLine("Registering with master server (Guid: " + guid + ", InternalIp: " + internalIp + ", PublicInfo: ...)"); }
public void checkForStatusUpdate(NetPeer netPeer, NetConnection connection, int team) { if (/*AmountChanged && */ ((team == Player.Me.Team && timeSinceStatusUpdate >= statusUpdateDelay) || Depleted)) { timeSinceStatusUpdate = 0f; AmountChanged = false; NetOutgoingMessage msg = netPeer.CreateMessage(); msg.Write(MessageID.RESOURCE_STATUS_UPDATE); msg.Write(ID); msg.Write((short)Amount); netPeer.SendMessage(msg, connection, NetDeliveryMethod.ReliableOrdered); } }
internal void sendTurretToKill(int v) { if (_game.state == GameState.MultiplayerRunningScreen) { if (_role == NetRole.Server) { NetOutgoingMessage om = _peer.CreateMessage(); om.Write((int)MessageType.UpdateTurrets); om.Write(v); _peer.SendMessage(om, _peer.Connections[0], NetDeliveryMethod.Unreliable); } } }
public bool Connect() { if (mNetwork.Configuration.IsServer) { throw new InvalidOperationException("Server interfaces cannot use Connect()."); } Log.Info($"Connecting to {mNetwork.Configuration.Host}:{mNetwork.Configuration.Port}..."); var handshakeSecret = new byte[32]; mRng.GetNonZeroBytes(handshakeSecret); var connectionRsa = new RSACryptoServiceProvider(2048); var hailParameters = connectionRsa.ExportParameters(false); var hail = new HailPacket(mRsa, handshakeSecret, SharedConstants.VersionData, hailParameters); hail.Encrypt(); var hailMessage = mPeer.CreateMessage(hail.Data.Length); if (hailMessage == null) { throw new InvalidOperationException(); } hailMessage.Data = hail.Data; hailMessage.LengthBytes = hail.Data.Length; if (mPeer.Status == NetPeerStatus.NotRunning) { mPeer.Start(); } var connection = mPeer.Connect(mNetwork.Configuration.Host, mNetwork.Configuration.Port, hailMessage); var server = new LidgrenConnection( mNetwork, Guid.Empty, connection, handshakeSecret, connectionRsa.ExportParameters(true) ); if (mNetwork.AddConnection(server)) { return(true); } Log.Error("Failed to add connection to list."); connection?.Disconnect("client_error"); return(false); }
/// <summary> /// Creates an outgoing message with the given sender, message, broadcast state. /// </summary> /// <param name="sender">The player who is sending this message.</param> /// <param name="message">The message to send.</param> /// <param name="broadcast">If the server receives this message, should it broadcast it out /// to all clients?</param> private NetOutgoingMessage CreateMessage(Player sender, INetworkMessage message, bool broadcast) { string serialized = SerializationHelpers.Serialize(new NetworkMessageFormat() { IfServerRebroadcast = broadcast, Sender = sender, NetworkMessage = message }); NetPeer peer = Peer; NetOutgoingMessage msg = peer.CreateMessage(); msg.Write(serialized); return(msg); }
public void SendObject(object obj, bool reliableTransfer = false, NetConnection connection = null) { var connections = Connections; if (connection != null) { connections = new List <NetConnection>() { connection }; } if (Connections.Count == 0) { return; } var msg = Peer.CreateMessage(); WriteHeader(msg, MessageType.Object); var type = obj.GetType(); var sync = SynchronizingInfo.InfoByType[type]; // Write the 16-bit type id var typeId = sync.TypeId; msg.Write(typeId); // Write the 32-bit object id var objId = sync.IsIdentifiable ? sync.ObjectToId(obj) : 0; msg.Write(objId); // Write the actual object contents if (sync.CustomSerializer != null) { sync.CustomSerializer(msg, obj); } else { string serialized = JsonConvert.SerializeObject(obj); msg.Write(serialized); } Peer.SendMessage(msg, Connections, reliableTransfer ? NetDeliveryMethod.ReliableOrdered : NetDeliveryMethod.UnreliableSequenced, reliableTransfer ? 0 : 1); }
public static NetOutgoingMessage Create([PexAssumeNotNull] string content, [PexAssumeNotNull] string appIdentifier, [PexAssumeNotNull] byte[] source) { PexAssume.IsTrue(!string.IsNullOrEmpty(appIdentifier)); NetPeerConfiguration config = new NetPeerConfiguration(appIdentifier); NetPeer peer = new NetPeer(config); NetOutgoingMessage outM = peer.CreateMessage(content); outM.Write(source); return(outM); // TODO: Edit factory method of NetOutgoingMessage // This method should be able to configure the object in all possible ways. // Add as many parameters as needed, // and assign their values to each field by using the API. }