static void AppLoop(object sender, EventArgs e)
{
while (NativeMethods.AppStillIdle)
{
// read any incoming messages
NetIncomingMessage im;
while ((im = Peer.ReadMessage()) != null)
{
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
MainForm.richTextBox1.AppendText(im.ReadString() + Environment.NewLine);
break;
case NetIncomingMessageType.UnconnectedData:
MainForm.richTextBox1.AppendText("Received from " + im.SenderEndPoint + ": " + im.ReadString() + Environment.NewLine);
Peer.Recycle(im);
break;
}
Peer.Recycle(im);
}
System.Threading.Thread.Sleep(1);
}
}
public void RecycleMessage(NetIncomingMessage msg)
{
if (msg != null && peer != null)
{
peer.Recycle(msg);
}
}
public void Update()
{
NetIncomingMessage msg;
while ((msg = Net.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Log(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
OnStatusChanged(msg);
break;
case NetIncomingMessageType.Data:
OnData(msg);
break;
default:
Log($"Unknown Message Type: {msg.MessageType}");
break;
}
Net.Recycle(msg);
}
}
public static async void Start()
{
var config = new NetPeerConfiguration("masterserver")
{
AutoFlushSendQueue = false, //Set it to false so lidgren doesn't wait until msg.size = MTU for sending
Port = Port,
SuppressUnreliableUnorderedAcks = true,
PingInterval = 500,
ConnectionTimeout = ServerMsTimeout
};
config.EnableMessageType(NetIncomingMessageType.UnconnectedData);
var peer = new NetPeer(config);
peer.Start();
CheckMasterServerListed();
ConsoleLogger.Log(LogLevels.Normal, $"Master server {LmpVersioning.CurrentVersion} started! Поехали!");
RemoveExpiredServers();
while (RunServer)
{
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
ConsoleLogger.Log(LogLevels.Debug, msg.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
ConsoleLogger.Log(LogLevels.Warning, msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
ConsoleLogger.Log(LogLevels.Error, msg.ReadString());
break;
case NetIncomingMessageType.UnconnectedData:
if (FloodControl.AllowRequest(msg.SenderEndPoint.Address))
{
var message = GetMessage(msg);
if (message != null && !message.VersionMismatch)
{
HandleMessage(message, msg, peer);
message.Recycle();
}
peer.Recycle(msg);
}
break;
}
}
await Task.Delay(ServerMsTick);
}
peer.Shutdown("Goodbye and thanks for all the fish!");
}
/// <summary>
/// Called when [update frame] occurs.
/// </summary>
public void OnUpdateFrame()
{
NetIncomingMessage msg;
if (_netPeer != null)
{
while ((msg = _netPeer.ReadMessage()) != null)
{
IncomingMsg.Add(ReadMessage(msg));
_netPeer.Recycle(msg);
}
}
if (_netClient != null)
{
while ((msg = _netClient.ReadMessage()) != null)
{
IncomingMsg.Add(ReadMessage(msg));
_netClient.Recycle(msg);
}
}
if (_netServer != null)
{
while ((msg = _netServer.ReadMessage()) != null)
{
IncomingMsg.Add(ReadMessage(msg));
_netServer.Recycle(msg);
}
}
}
static void UdpMain(GameList gameList)
{
var config = new NetPeerConfiguration("SpagAachen.Ballz");
config.Port = 43117;
config.EnableMessageType(NetIncomingMessageType.UnconnectedData);
var peer = new NetPeer(config);
peer.Start();
while (true)
{
Thread.Sleep(10);
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.UnconnectedData:
gameList.RequestAddGame(msg);
break;
}
peer.Recycle(msg);
}
}
}
void ReadInData()
{
NetworkMessage client_input = new NetworkMessage();
NetIncomingMessage im;
while ((im = server.ReadMessage()) != null)
{
switch (im.MessageType)
{
case NetIncomingMessageType.Data:
byte[] msg = im.ReadBytes(im.LengthBytes);
client_input = NetworkMessage.Deserialize(msg);
OutputQueue.AddToQueue(client_input.GetData());
Debug.WriteLine(msg);
break;
case NetIncomingMessageType.DiscoveryRequest:
// Create a response
NetOutgoingMessage om = server.CreateMessage();
om.Write("Connecting to DOG server");
server.SendDiscoveryResponse(om, im.SenderEndPoint);
break;
case NetIncomingMessageType.UnconnectedData:
Debug.WriteLine("Received from " + im.SenderEndPoint + ": " + im.ReadString() + Environment.NewLine);
break;
}
server.Recycle(im);
}
}
protected void Update()
{
NetIncomingMessage msg;
while ((msg = instance.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.Data:
var index = msg.ReadUInt32();
methods[index].Invoke(msg);
break;
default:
Console.WriteLine("Unhandled type: " + msg.MessageType);
break;
}
instance.Recycle(msg);
}
}
public void MessagePump()
{
NetIncomingMessage nim;
while ((nim = netpeer.ReadMessage()) != null)
{
switch (nim.MessageType)
{
case NetIncomingMessageType.StatusChanged:
OnStatusChanged(nim);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.Error:
OnDebugMessage(nim);
break;
default:
OnUnknownMessage(nim);
break;
}
netpeer.Recycle(nim);
}
}
public bool ReceiveOne()
{
NetIncomingMessage message = Peer.ReadMessage();
if (message != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.Data:
onDataMessage(message);
break;
case NetIncomingMessageType.StatusChanged:
onStatusChanged(message);
break;
default:
onInternalMessage(message);
break;
}
Peer.Recycle(message);
return(true);
}
return(false);
}
internal Task ProcessNetworkMessages(NetPeer peer)
{
return(Task.Run(async() =>
{
NetIncomingMessage im;
peer.MessageReceivedEvent.WaitOne();
while ((im = peer.ReadMessage()) != null)
{
if (im.SenderConnection != null)
{
if (connectionHandler.HasKey(im.SenderConnection))
{
await connectionHandler[im.SenderConnection].Invoke(im.MessageType, im);
}
}
foreach (var handler in globalHandler.GetAll)
{
await handler(im.MessageType, im);
}
if (messageHandlers.HasKey(im.MessageType))
{
await messageHandlers[im.MessageType].Invoke(im);
}
peer.Recycle(im);
}
}));
}
static private void ParseMessage(NetIncomingMessage message)
{
Console.WriteLine("Received message with type: " + message.MessageType);
switch (message.MessageType)
{
case NetIncomingMessageType.Data:
ParseMessage_Data(message);
break;
case NetIncomingMessageType.StatusChanged:
ParseMessage_Status(message);
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;
}
NetworkHandler.Recycle(message);
}
public void HandleWebConnections()
{
NetIncomingMessage message;
while ((message = peer.ReadMessage()) != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.Data:
HandleData(message);
break;
case NetIncomingMessageType.StatusChanged:
switch (message.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
Debug.WriteLine("Connected!");
break;
case NetConnectionStatus.Disconnected:
Debug.WriteLine("Disconnected...");
break;
}
break;
case NetIncomingMessageType.ConnectionApproval:
message.SenderConnection.Approve();
break;
case NetIncomingMessageType.DiscoveryResponse:
peer.Connect(message.SenderEndPoint);
connecting = false;
break;
case NetIncomingMessageType.DiscoveryRequest:
var msg = peer.CreateMessage();
msg.Write("hi");
peer.SendDiscoveryResponse(msg, message.SenderEndPoint);
peer.Connect(message.SenderEndPoint);
isServer = true;
break;
case NetIncomingMessageType.DebugMessage:
Debug.WriteLine(message.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Debug.WriteLine(message.ReadString());
break;
default:
Debug.WriteLine("unhandled message with type: "
+ message.MessageType);
break;
}
peer.Recycle(message);
}
}
private static void Main(string[] args)
{
map.generate();
Console.WriteLine(("Enter Server name:"));
var name = Console.ReadLine();
var config = new NetPeerConfiguration("PythonRouge")
{
Port = 32078
};
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
Server = new NetServer(config);
Server.Start();
Console.WriteLine("Ready");
NetIncomingMessage msg;
while (true)
{
while ((msg = Server.ReadMessage()) != null)
{
Console.WriteLine("Got Message");
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
string reason = msg.ReadString();
Console.WriteLine(status + " " + reason);
break;
case NetIncomingMessageType.ConnectionApproval:
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.Data:
msgHandler(msg);
break;
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.DiscoveryRequest:
// Create a response and write some example data to it
NetOutgoingMessage response = Server.CreateMessage();
Console.WriteLine("Client request");
response.Write(name);
// Send the response to the sender of the request
Server.SendDiscoveryResponse(response, msg.SenderEndPoint);
break;
default:
Console.WriteLine("Unhandled type: " + msg.MessageType);
break;
}
Server.Recycle(msg);
}
}
}
protected void ReadMessages()
{
if (peer != null)
{
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.Data:
byte messageId = msg.ReadByte();
Action <NetIncomingMessage> handler = null;
if (messageHandlers.TryGetValue(messageId, out handler))
{
handler(msg);
}
else
{
Debug.LogWarning("No handler for message id " + messageId);
}
break;
case NetIncomingMessageType.StatusChanged:
switch (msg.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
if (Connected != null)
{
Connected(msg.SenderConnection);
}
break;
case NetConnectionStatus.Disconnected:
if (Disconnected != null)
{
Disconnected(msg.SenderConnection);
}
break;
}
Debug.Log("Status on " + msg.SenderConnection + " changed to " + msg.SenderConnection.Status);
break;
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
Debug.Log("Lidgren: " + msg.ReadString());
break;
}
peer.Recycle(msg);
}
}
}
protected void ReadMessages()
{
if (peer == null)
{
return;
}
NetIncomingMessage netIncomingMessage;
while ((netIncomingMessage = peer.ReadMessage()) != null)
{
switch (netIncomingMessage.MessageType)
{
case NetIncomingMessageType.Data:
{
byte b = netIncomingMessage.ReadByte();
Action <NetIncomingMessage> value = null;
if (messageHandlers.TryGetValue(b, out value))
{
value(netIncomingMessage);
}
else
{
Debug.LogWarning("No handler for message id " + b);
}
break;
}
case NetIncomingMessageType.StatusChanged:
switch (netIncomingMessage.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
if (this.Connected != null)
{
this.Connected(netIncomingMessage);
}
break;
case NetConnectionStatus.Disconnected:
if (this.Disconnected != null)
{
this.Disconnected(netIncomingMessage);
}
break;
}
Debug.Log(string.Concat("Status on ", netIncomingMessage.SenderConnection, " changed to ", netIncomingMessage.SenderConnection.Status));
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Debug.Log("Lidgren: " + netIncomingMessage.ReadString());
break;
}
peer.Recycle(netIncomingMessage);
}
}
public void Update()
{
NetIncomingMessage message;
while ((message = _peer.ReadMessage()) != null)
{
ReadMessage(message);
_peer.Recycle(message);
}
}
/// <summary>
/// Reads incoming messages. To be called continuously.
/// </summary>
public virtual void Update(int msElapsed)
{
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
HandleIncomingMessage(msg);
peer.Recycle(msg);
}
}
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);
}
}
/// <summary>
/// Always checks if there's a incoming message and tells the manager.
/// </summary>
public void ProcessMessages()
{
while (Listening)
{
Thread.Sleep(1);
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
//Server only Messages
case NetIncomingMessageType.DiscoveryRequest:
((NetServerManager)manager).OnDiscoverRequest(msg);
break;
case NetIncomingMessageType.ConnectionApproval:
((NetServerManager)manager).OnConnectionApproval(msg);
break;
//Client only Messages
case NetIncomingMessageType.DiscoveryResponse:
((NetClientManager)manager).OnDiscoverResponse(msg);
break;
//Server and Client Messages
case NetIncomingMessageType.Data: //Data messages are converted in packets and then transmitted further
var packet = Packet.ToPacket(msg);
manager.RecievePacket(packet);
break;
case NetIncomingMessageType.StatusChanged:
manager.StatusChange(msg);
break;
//Error Messages
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Debug.WriteLine(msg.ReadString());
break;
default:
Debug.WriteLine(Properties.strings.listenerUnhandledMessage, msg.MessageType);
break;
}
peer.Recycle(msg);
}
}
Debug.WriteLine(Properties.strings.listenerThreadFinished);
}
/// <summary>
/// Reads any messages in the queue and updates Entities accordingly.
/// Usually called in the game loop.
/// Read messages are recycled at each iteration.
/// </summary>
public void Update()
{
lastUpdateDelta = ServerTime - lastUpdateTime;
lastUpdateTime = ServerTime;
// early out, don't update if network not running
// allows generic update call in main gameloop before
// network has initialized
if (network == null || network.Status != NetPeerStatus.Running)
{
return;
}
NetIncomingMessage msg;
while ((msg = network.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
log.Debug(msg.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
log.Warning(msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
log.Error(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
ProcessStatusChangedMessage(msg);
break;
case NetIncomingMessageType.Data:
ProcessDataMessage(msg);
break;
}
network.Recycle(msg);
}
if (Configuration.DeadReckonSeconds > 0)
{
timeToDeadReckon -= lastUpdateDelta;
if (timeToDeadReckon <= 0)
{
DeadReckon();
timeToDeadReckon = Configuration.DeadReckonSeconds;
}
}
}
/// <summary>
/// Process incoming packets.
/// </summary>
public void ProcessPackets()
{
// client does not always have its networking running, for example on main menu
if (IsClient && _netPeer == null)
{
return;
}
// server on the other hand needs it to be running
DebugTools.Assert(_netPeer != null);
NetIncomingMessage msg;
while ((msg = _netPeer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
Logger.DebugS("net", msg.ReadString());
break;
case NetIncomingMessageType.DebugMessage:
Logger.InfoS("net", msg.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Logger.WarningS("net", msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Logger.ErrorS("net", msg.ReadString());
break;
case NetIncomingMessageType.ConnectionApproval:
HandleApproval(msg);
break;
case NetIncomingMessageType.Data:
DispatchNetMessage(msg);
break;
case NetIncomingMessageType.StatusChanged:
HandleStatusChanged(msg);
break;
default:
Logger.WarningS("net", "{msg.SenderConnection.RemoteEndPoint.Address}: Unhandled incoming packet type: {msg.MessageType}");
break;
}
_netPeer.Recycle(msg);
}
}
public void PeerListener(NetPeer peer)
{
while (true)
{
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
NetConnection connection = msg.SenderConnection;
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
switch (msg.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
logger.Info("{0}: connected", connection.RemoteEndPoint.Address.ToString());
ExecuteCommand(new CmdInitOk(connection));
break;
case NetConnectionStatus.Disconnected:
logger.Info("{0}: disconnected", connection.RemoteEndPoint.Address.ToString());
break;
case NetConnectionStatus.Disconnecting:
logger.Info("{0}: disconnecting", connection.RemoteEndPoint.Address.ToString());
break;
}
break;
case NetIncomingMessageType.Data:
msg.Decrypt(new NetRC2Encryption(peer, connection.CryptoKey));
string[] OpData = msg.ReadString().Split('&');
var OpCode = (LoginOperation)Enum.Parse(typeof(LoginOperation), OpData[0]);
switch (OpCode)
{
case LoginOperation.AuthLog:
string[] authData = OpData[1].Split('#');
string login = authData[0];
string pass = authData[1];
ExecuteCommand(new CmdLoginOkFail(connection, login, pass));
break;
}
break;
}
peer.Recycle(msg);
}
}
}
public static void HandlePeerMessages(object peer)
{
if (peer is NetPeer)
{
NetPeer p = ((NetPeer)peer);
NetIncomingMessage msg = ((NetPeer)peer).ReadMessage();
string machineName;
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
if (!peers.ContainsKey(msg.SenderEndpoint))
{
Console.WriteLine("DiscoveryRequest from " + msg.SenderEndpoint.Address + " port: " + msg.SenderEndpoint.Port);
NetOutgoingMessage requestResponse = p.CreateMessage();
requestResponse.Write(Environment.MachineName);
p.SendDiscoveryResponse(requestResponse, msg.SenderEndpoint);
}
break;
case NetIncomingMessageType.DiscoveryResponse:
machineName = msg.ReadString();
Boolean connectedToPeer = false;
foreach (NetConnection conn in p.Connections)
{
if (conn.RemoteEndpoint == msg.SenderEndpoint)
{
connectedToPeer = true;
}
}
if (!connectedToPeer)
{
if (!peers.ContainsKey(msg.SenderEndpoint))
{
Console.WriteLine("DiscoveryResponse from " + msg.SenderEndpoint.Address + " port: " + msg.SenderEndpoint.Port +
" machine name: " + machineName);
peers.Add(msg.SenderEndpoint, machineName);
}
NetOutgoingMessage hailMessage = p.CreateMessage();
hailMessage.Write(Environment.MachineName);
NetConnection senderConn = p.Connect(msg.SenderEndpoint, hailMessage);
}
break;
}
p.Recycle(msg);
}
}
public void Refresh()
{
NetIncomingMessage message;
while ((message = peer.ReadMessage()) != null)
{
switch (message.MessageType)
{
}
peer.Recycle(message);
}
}
public bool TryGetInboundBuffer(out IBuffer buffer, out IConnection connection)
{
buffer = default(IBuffer);
connection = default(IConnection);
var message = TryHandleInboundMessage();
if (message == null)
{
return(true);
}
var lidgrenId = message.SenderConnection?.RemoteUniqueIdentifier ?? -1;
Debug.Assert(mGuidLookup != null, "mGuidLookup != null");
if (!mGuidLookup.TryGetValue(lidgrenId, out var guid))
{
Log.Error($"Missing connection: {guid}");
mPeer.Recycle(message);
return(false);
}
connection = mNetwork.FindConnection(guid);
if (connection != null)
{
var lidgrenConnection = connection as LidgrenConnection;
if (lidgrenConnection?.Aes == null)
{
Log.Error("No provider to decrypt data with.");
return(false);
}
if (!lidgrenConnection.Aes.Decrypt(message))
{
Log.Error($"Error decrypting inbound Lidgren message [Connection:{connection.Guid}].");
return(false);
}
}
else
{
Log.Warn($"Received message from an unregistered endpoint.");
}
buffer = new LidgrenBuffer(message);
return(true);
}
void HandleWebConnections()
{
NetIncomingMessage message;
while ((message = peer.ReadMessage()) != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.Data:
// data code
break;
case NetIncomingMessageType.StatusChanged:
switch (message.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
Debug.WriteLine("Connected!");
break;
case NetConnectionStatus.Disconnected:
ship2 = null;
Debug.WriteLine("Disconnected...");
break;
}
break;
case NetIncomingMessageType.DiscoveryResponse:
peer.Connect("176.135.163.41", 8000, peer.CreateMessage("yes"));
break;
case NetIncomingMessageType.DiscoveryRequest:
var msg = peer.CreateMessage();
msg.Write("hi");
peer.SendDiscoveryResponse(msg, message.SenderEndPoint);
break;
case NetIncomingMessageType.DebugMessage:
Console.WriteLine(message.ReadString());
break;
default:
Console.WriteLine("unhandled message with type: "
+ message.MessageType);
break;
}
peer.Recycle(message);
}
}
/// <summary>
/// Reads incoming messages. Call in a game loop.
/// </summary>
/// <param name="msgHandler">A function that handles data messages.</param>
/// <param name="statusHandler">A function that handles status messages.</param>
public void ReadMessages(Action <NetIncomingMessage> msgHandler,
Action <NetConnectionStatus> statusHandler)
{
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
connected = true;
}
statusHandler(status);
break;
case NetIncomingMessageType.ConnectionApproval:
if (connected)
{
msg.SenderConnection.Deny();
}
else
{
msg.SenderConnection.Approve();
}
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.Error:
logMessage(msg.ReadString());
break;
case NetIncomingMessageType.Data:
msgHandler(msg);
break;
default:
logMessage($"Unhandled type: {msg.MessageType}");
break;
}
peer.Recycle(msg);
}
}
/// <summary>
/// Process incoming packets.
/// </summary>
public void ProcessPackets()
{
Debug.Assert(_netPeer != null);
NetIncomingMessage msg;
while ((msg = _netPeer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
Logger.Debug($"[NET] {msg.ReadString()}");
break;
case NetIncomingMessageType.DebugMessage:
Logger.Info("[NET] " + msg.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Logger.Warning("[NET] " + msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Logger.Error("[NET] " + msg.ReadString());
break;
case NetIncomingMessageType.ConnectionApproval:
HandleApproval(msg);
break;
case NetIncomingMessageType.Data:
DispatchNetMessage(msg);
break;
case NetIncomingMessageType.StatusChanged:
HandleStatusChanged(msg);
break;
default:
Logger.Warning($"[NET] {msg.SenderConnection.RemoteEndPoint.Address}: Unhandled incoming packet type: {msg.MessageType}");
break;
}
_netPeer.Recycle(msg);
}
}
private void OnMessageReceivedCallback(object netPeerObject)
{
// It could be a library message
var incomingMessage = netPeer.ReadMessage();
switch (incomingMessage.MessageType)
{
case NetIncomingMessageType.StatusChanged:
HandleStatusChangeMessage(incomingMessage);
break;
case NetIncomingMessageType.UnconnectedData:
HandleUnconnectedDataMessage(incomingMessage);
break;
case NetIncomingMessageType.NatIntroductionSuccess:
HandleNatIntroductionSuccessMessage(incomingMessage);
break;
case NetIncomingMessageType.Data:
HandleDataMessage(incomingMessage);
break;
case NetIncomingMessageType.DebugMessage:
HandleDebugMessage(incomingMessage);
break;
case NetIncomingMessageType.VerboseDebugMessage:
HandleDebugMessage(incomingMessage);
break;
case NetIncomingMessageType.WarningMessage:
HandleDebugMessage(incomingMessage);
break;
case NetIncomingMessageType.ErrorMessage:
HandleDebugMessage(incomingMessage);
break;
}
netPeer.Recycle(incomingMessage);
}
