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.
}
