public static void Connect(string host, int port)
{
if (client != null)
Disconnect();
lastStatus = NetConnectionStatus.None;
players.Clear();
NetPeerConfiguration config = new NetPeerConfiguration("HumanityAgainstCards")
{
MaximumHandshakeAttempts = 1,
ConnectionTimeout = 10,
PingInterval = 1
};
client = new NetClient(config);
client.Start();
client.Connect(host, port);
Hand = new List<Card>();
CurrentBlackCard = null;
gotBrainTumorOnce = false;
InMatch = false;
Console.WriteLine("Client running...");
}
public void OnStatusMessage(object sender, NetConnectionStatus status, String reason)
{
if (StatusMessage != null)
{
StatusMessage(sender, new StatusMessageArgs((NetworkHelper.NetConnectionStatus)status, reason));
}
}
public void Dispatch(NetConnectionStatus status)
{
LidgrenStatusMessage message = new LidgrenStatusMessage(status);
//Just dispatch as a real status message
this.OnNetworkMessageReceive(message, null);
}
/// <summary>
/// Waits until specified status in not cleared.
/// </summary>
public static void WaitForStatusCleared(this NetConnection connection, NetConnectionStatus status)
{
while (connection.Status == status)
{
Thread.Sleep(5);
}
}
public LidgrenStatusChangeMessageContext(NetIncomingMessage incomingMessage)
: base(incomingMessage)
{
LidgrenStatus = (NetConnectionStatus)incomingMessage.ReadByte();
//Generate a Lidgren status message for dispatching
GeneratedStatusMessage = new LidgrenStatusMessage(LidgrenStatus);
}
public override void StatusChanged(NetConnectionStatus status, string message, NetConnection connection)
{
if (status==NetConnectionStatus.Connected) {
string serverInfo = connection.RemoteHailMessage.PeekString();
gameClient.SetState( new Loading( gameClient, connection.RemoteHailMessage.PeekString() ) );
}
if (status==NetConnectionStatus.Disconnected) {
gameClient.SetState( new Disconnected( gameClient, message ) );
}
}
public NetStatusChangedEventArgs(
NetConnection connection,
NetConnectionStatus oldStatus,
NetConnectionStatus newStatus,
string reason
)
{
m_connection = connection;
m_oldStatus = oldStatus;
m_newStatus = newStatus;
m_reason = reason;
}
internal NetConnection(NetPeer peer, IPEndPoint remoteEndpoint)
{
m_peer = peer;
m_peerConfiguration = m_peer.Configuration;
m_status = NetConnectionStatus.None;
m_visibleStatus = NetConnectionStatus.None;
m_remoteEndpoint = remoteEndpoint;
m_sendChannels = new NetSenderChannelBase[NetConstants.NumTotalChannels];
m_receiveChannels = new NetReceiverChannelBase[NetConstants.NumTotalChannels];
m_queuedAcks = new NetQueue<NetTuple<NetMessageType, int>>(4);
m_statistics = new NetConnectionStatistics(this);
m_averageRoundtripTime = -1.0f;
}
internal NetConnection(NetPeer peer, NetEndPoint remoteEndPoint)
{
m_peer = peer;
m_peerConfiguration = m_peer.Configuration;
m_status = NetConnectionStatus.None;
m_outputtedStatus = NetConnectionStatus.None;
m_visibleStatus = NetConnectionStatus.None;
m_remoteEndPoint = remoteEndPoint;
m_sendChannels = new NetSenderChannelBase[NetConstants.NumTotalChannels];
m_receiveChannels = new NetReceiverChannelBase[NetConstants.NumTotalChannels];
m_queuedOutgoingAcks = new NetQueue<NetTuple<NetMessageType, int>>(4);
m_queuedIncomingAcks = new NetQueue<NetTuple<NetMessageType, int>>(4);
m_statistics = new NetConnectionStatistics(this);
m_averageRoundtripTime = -1.0f;
m_currentMTU = m_peerConfiguration.MaximumTransmissionUnit;
}
internal void SetStatus(NetConnectionStatus status, string reason)
{
// Connecting status is given to NetConnection at startup, so we must treat it differently
if (m_status == status && status != NetConnectionStatus.Connecting)
return;
//m_owner.LogWrite("New connection status: " + status + " (" + reason + ")");
NetConnectionStatus oldStatus = m_status;
m_status = status;
if (m_status == NetConnectionStatus.Connected)
{
// no need for further hole punching
m_owner.CeaseHolePunching(m_remoteEndPoint);
}
m_owner.NotifyStatusChange(this, reason);
}
private void ConnectionStatusChanged(NetConnectionStatus currentStatus, string message)
{
System.Diagnostics.Debug.WriteLine($"connection status changed to {currentStatus}");
switch (currentStatus)
{
case NetConnectionStatus.Connected:
EventQueue.Enqueue(new StatusUpdate.JoinedGame());
break;
case NetConnectionStatus.Disconnected:
EventQueue.Enqueue(new StatusUpdate.LeftGame(message, !IsAttemptingToDisconnect));
break;
default:
break;
}
}
internal NetConnection(NetBase owner, IPEndPoint remoteEndPoint, byte[] localHailData, byte[] remoteHailData)
{
m_owner = owner;
m_remoteEndPoint = remoteEndPoint;
m_localHailData = localHailData;
m_remoteHailData = remoteHailData;
m_futureClose = double.MaxValue;
m_throttleDebt = owner.m_config.m_throttleBytesPerSecond; // slower start
m_statistics = new NetConnectionStatistics(this, 1.0f);
m_unsentMessages = new NetQueue<OutgoingNetMessage>(6);
m_lockedUnsentMessages = new NetQueue<OutgoingNetMessage>(3);
m_status = NetConnectionStatus.Connecting; // to prevent immediate removal on heartbeat thread
InitializeReliability();
InitializeFragmentation();
InitializeStringTable();
//InitializeCongestionControl(32);
}
public override void StatusChanged(NetConnectionStatus status, string message, NetConnection connection)
{
if (status==NetConnectionStatus.Disconnected) {
disconnectReason = message;
}
}
/// <summary>
/// Called when NetClient changed its status
/// </summary>
/// <param name="status"></param>
/// <param name="message"></param>
/// <param name="connection"></param>
public override void StatusChanged(NetConnectionStatus status, string message, NetConnection connection)
{
if (status==NetConnectionStatus.Disconnected) {
gameClient.SetState( new Disconnected(gameClient, message) );
}
}
public override void OnStatusChange(NetConnection connection, NetConnectionStatus status)
{
switch (status)
{
case NetConnectionStatus.None:
break;
case NetConnectionStatus.InitiatedConnect:
break;
case NetConnectionStatus.RespondedAwaitingApproval:
break;
case NetConnectionStatus.RespondedConnect:
break;
case NetConnectionStatus.Connected:
{
AddConnection(connection);
}
break;
case NetConnectionStatus.Disconnecting:
for (int i = 0; i < players.Count; i++)
{
if (players[i] == connection.Tag)
{
var memory = new MemoryStream();
var writer = new BinaryWriter(memory);
players[i].Status = Player.StatusTypes.Left;
writer.Write((byte) Gamemode.Signature.PlayerLeft);
writer.Write(players[i].ClientId);
SendData(memory.ToArray(), Gamemode.Signature.Custom);
writer.Close();
memory.Close();
players.RemoveAt(i);
break;
}
}
break;
case NetConnectionStatus.Disconnected:
break;
default:
break;
}
}
public StatusChangedEventArgs(NetConnectionStatus setStatus, string setReason)
{
status = setStatus;
reason = setReason;
}
public void Connect(IPEndPoint endPoint)
{
DisconnectReason = null;
NetPeerConfiguration config = new NetPeerConfiguration("MulTUNG");
Client = new NetClient(config);
Client.Start();
var approval = Client.CreateMessage();
approval.Write(MulTUNG.Version.ToString());
approval.Write(Username);
var conn = Client.Connect(endPoint, approval);
ThreadPool.QueueUserWorkItem(o =>
{
var c = o as NetConnection;
int elapsed = 0;
while (true)
{
Thread.Sleep(50);
elapsed += 50;
if ((c.Status != NetConnectionStatus.Connected && elapsed >= Constants.WaitForConnection) || DisconnectReason != null)
{
Network.IsClient = false;
string status = MulTUNG.Status = "Couldn't connect to remote server." + (DisconnectReason != null ? " Check the console for more details." : "");
IGConsole.Error("Couldn't connect to remote server: " + DisconnectReason);
Thread.Sleep(3000);
MulTUNG.ShowMainMenuCanvases();
MulTUNG.ShowStatusWindow = false;
MulTUNG.Status = "";
break;
}
else if (c.Status == NetConnectionStatus.Connected)
{
Network.IsClient = true;
MulTUNG.SynchronizationContext.Send(_ =>
{
SaveManager.SaveName = MulTUNG.ForbiddenSaveName;
World.DeleteSave();
SceneManager.LoadScene("gameplay");
EverythingHider.HideEverything();
}, null);
while (ModUtilities.IsOnMainMenu)
{
Thread.Sleep(500);
}
Thread.Sleep(1000);
IsInGameplay = true;
EnterEvent.Set();
InitWorld();
break;
}
}
}, conn);
ThreadPool.QueueUserWorkItem(_ =>
{
NetIncomingMessage msg;
while (Client.Status == NetPeerStatus.Running)
{
msg = Client.WaitMessage(int.MaxValue);
if (msg == null)
{
continue;
}
switch (msg.MessageType)
{
case NetIncomingMessageType.Data:
var packet = PacketDeserializer.DeserializePacket(new MessagePacketReader(msg));
if (Network.ProcessPacket(packet, this.PlayerID))
{
PacketLog.LogReceive(packet);
}
break;
case NetIncomingMessageType.StatusChanged:
var status = (NetConnectionStatus)msg.ReadByte();
Log.WriteLine("Status: " + status);
if (status == NetConnectionStatus.Disconnected)
{
string reason = msg.ReadString();
if (!string.IsNullOrEmpty(reason))
{
DisconnectReason = reason;
}
Disconnect();
}
LastStatus = Client.ConnectionStatus;
break;
}
Client.Recycle(msg);
}
});
}
private void receiveMessage()
{
NetIncomingMessage im;
while ((im = session.ReadMessage()) != null)
{
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
Console.WriteLine(im.ReadString() + "\n");
break;
case NetIncomingMessageType.UnconnectedData:
Console.WriteLine(im.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
// When a new player connects, the host is charged to find a suitable default name between player1 and player4
// depending on what names are available. The host then sends the new list of player names to the other players
if (status == NetConnectionStatus.Connected)
{
/*packetWriter = session.CreateMessage();
* packetWriter.Write((Byte)ConnectedMessageType.Chat);
* packetWriter.Write("Hello");
* session.SendMessage(packetWriter, im.SenderConnection, NetDeliveryMethod.ReliableOrdered);*/
}
if (status == NetConnectionStatus.Disconnected)
{
}
// Don't need this for now
string reason = im.ReadString();
Console.WriteLine(status.ToString() + ": " + reason);
break;
case NetIncomingMessageType.Data:
ConnectedMessageType connectedMessageType = (ConnectedMessageType)im.ReadByte();
switch (connectedMessageType)
{
case ConnectedMessageType.EndRoundInfo:
packetWriter = session.CreateMessage();
packetWriter.Write((Byte)ConnectedMessageType.EndRoundInfo);
packetWriter.Write(im.ReadString());
session.SendMessage(packetWriter, im.SenderConnection, NetDeliveryMethod.ReliableOrdered);
break;
case ConnectedMessageType.Ping:
packetWriter = session.CreateMessage();
packetWriter.Write((Byte)ConnectedMessageType.PingReply);
session.SendMessage(packetWriter, session.Connections, NetDeliveryMethod.ReliableOrdered, 0);
break;
case ConnectedMessageType.PingReply:
pingSent = false;
Console.WriteLine(watch.ElapsedMilliseconds);
break;
}
break;
default:
Console.WriteLine("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes \n");
break;
}
}
}
/// <summary>
/// Invokes ConnectionStatusChanged event.
/// </summary>
/// <param name="sender">NetConnection</param>
/// <param name="status">The current status of the connection</param>
/// <param name="remoteId">The remote ID of the connection</param>
protected virtual void OnConnectionStatusChanged(object sender, NetConnectionStatus status, Guid remoteId)
{
ConnectionStatusChanged?.Invoke(sender, new ConnectionStatusChangedEventArgs(status, remoteId));
}
private void MGServer_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
NetPeerConfiguration config = new NetPeerConfiguration(applicationIdentifier);
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
config.EnableMessageType(NetIncomingMessageType.NatIntroductionSuccess);
if (availableSession == null)
{
config.Port = port;
}
// create and start server
peer = new NetServer(config);
peer.Start();
myLocalAddress = GetMyLocalIpAddress();
IPAddress adr = IPAddress.Parse(myLocalAddress);
myLocalEndPoint = new IPEndPoint(adr, port);
// force a little wait until we have a LocalGamer otherwise things
// break. This is the first item in the queue so it shouldnt take long before we
// can continue.
while (session.LocalGamers.Count <= 0)
{
Thread.Sleep(10);
}
if (availableSession != null)
{
if (!this.online)
{
peer.Connect(availableSession.EndPoint);
}
else
{
RequestNATIntroduction(availableSession.EndPoint, peer);
}
}
else
{
if (this.online)
{
IPAddress ipaddr = NetUtility.Resolve(masterServer);
if (ipaddr != null)
{
m_masterServer = new IPEndPoint(ipaddr, masterserverport);
LocalNetworkGamer localMe = session.LocalGamers [0];
NetOutgoingMessage om = peer.CreateMessage();
om.Write((byte)0);
om.Write(session.AllGamers.Count);
om.Write(localMe.Gamertag);
om.Write(session.PrivateGamerSlots);
om.Write(session.MaxGamers);
om.Write(localMe.IsHost);
om.Write(myLocalEndPoint);
om.Write(peer.Configuration.AppIdentifier);
// send up session properties
int[] propertyData = new int[session.SessionProperties.Count * 2];
NetworkSessionProperties.WriteProperties(session.SessionProperties, propertyData);
for (int x = 0; x < propertyData.Length; x++)
{
om.Write(propertyData [x]);
}
peer.SendUnconnectedMessage(om, m_masterServer); // send message to peer
}
else
{
throw new Exception("Could not resolve live host");
}
}
}
// run until we are done
do
{
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.UnconnectedData:
break;
case NetIncomingMessageType.NatIntroductionSuccess:
#if !WINDOWS_PHONE
Game.Instance.Log("NAT punch through OK " + msg.SenderEndpoint);
#endif
peer.Connect(msg.SenderEndpoint);
break;
case NetIncomingMessageType.DiscoveryRequest:
//
// Server received a discovery request from a client; send a discovery response (with no extra data attached)
//
// Get the primary local gamer
LocalNetworkGamer localMe = session.LocalGamers [0];
NetOutgoingMessage om = peer.CreateMessage();
om.Write(session.RemoteGamers.Count);
om.Write(localMe.Gamertag);
om.Write(session.PrivateGamerSlots);
om.Write(session.MaxGamers);
om.Write(localMe.IsHost);
int[] propertyData = new int[session.SessionProperties.Count * 2];
NetworkSessionProperties.WriteProperties(session.SessionProperties, propertyData);
for (int x = 0; x < propertyData.Length; x++)
{
om.Write(propertyData [x]);
}
peer.SendDiscoveryResponse(om, msg.SenderEndpoint);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
//
// Just print diagnostic messages to console
//
#if !WINDOWS_PHONE
Game.Instance.Log(msg.ReadString());
#endif
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Disconnected)
{
#if !WINDOWS_PHONE
Game.Instance.Log(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " disconnected! from " + msg.SenderEndpoint);
#endif
CommandGamerLeft cgj = new CommandGamerLeft(msg.SenderConnection.RemoteUniqueIdentifier);
CommandEvent cmde = new CommandEvent(cgj);
session.commandQueue.Enqueue(cmde);
}
if (status == NetConnectionStatus.Connected)
{
//
// A new player just connected!
//
if (!pendingGamers.ContainsKey(msg.SenderConnection.RemoteUniqueIdentifier))
{
#if !WINDOWS_PHONE
Game.Instance.Log(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected! from " + msg.SenderEndpoint);
#endif
pendingGamers.Add(msg.SenderConnection.RemoteUniqueIdentifier, msg.SenderConnection);
SendProfileRequest(msg.SenderConnection);
}
else
{
#if !WINDOWS_PHONE
Game.Instance.Log("Already have a connection for that user, this is probably due to both NAT intro requests working");
#endif
}
}
break;
case NetIncomingMessageType.Data:
NetworkMessageType mt = (NetworkMessageType)msg.ReadByte();
switch (mt)
{
case NetworkMessageType.Data:
byte[] data = new byte[msg.LengthBytes - 1];
msg.ReadBytes(data, 0, data.Length);
CommandEvent cme = new CommandEvent(new CommandReceiveData(msg.SenderConnection.RemoteUniqueIdentifier,
data));
session.commandQueue.Enqueue(cme);
break;
case NetworkMessageType.Introduction:
var introductionAddress = msg.ReadString();
try {
IPEndPoint endPoint = ParseIPEndPoint(introductionAddress);
if (myLocalEndPoint.ToString() != endPoint.ToString() && !AlreadyConnected(endPoint))
{
#if !WINDOWS_PHONE
Game.Instance.Log("Received Introduction for: " + introductionAddress +
" and I am: " + myLocalEndPoint + " from: " + msg.SenderEndpoint);
#endif
peer.Connect(endPoint);
}
} catch (Exception exc) {
#if !WINDOWS_PHONE
Game.Instance.Log("Error parsing Introduction: " + introductionAddress + " : " + exc.Message);
#endif
}
break;
case NetworkMessageType.GamerProfile:
#if !WINDOWS_PHONE
Game.Instance.Log("Profile recieved from: " + NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier));
#endif
if (pendingGamers.ContainsKey(msg.SenderConnection.RemoteUniqueIdentifier))
{
pendingGamers.Remove(msg.SenderConnection.RemoteUniqueIdentifier);
msg.ReadInt32();
string gamerTag = msg.ReadString();
msg.ReadInt32();
msg.ReadInt32();
GamerStates state = (GamerStates)msg.ReadInt32();
state &= ~GamerStates.Local;
CommandGamerJoined cgj = new CommandGamerJoined(msg.SenderConnection.RemoteUniqueIdentifier);
cgj.GamerTag = gamerTag;
cgj.State = state;
CommandEvent cmde = new CommandEvent(cgj);
session.commandQueue.Enqueue(cmde);
}
else
{
#if !WINDOWS_PHONE
Game.Instance.Log("We received a profile for an existing gamer. Need to update it.");
#endif
}
break;
case NetworkMessageType.RequestGamerProfile:
#if !WINDOWS_PHONE
Game.Instance.Log("Profile Request recieved from: " + msg.SenderEndpoint);
#endif
SendProfile(msg.SenderConnection);
break;
case NetworkMessageType.GamerStateChange:
GamerStates gamerstate = (GamerStates)msg.ReadInt32();
gamerstate &= ~GamerStates.Local;
#if !WINDOWS_PHONE
Game.Instance.Log("State Change from: " + msg.SenderEndpoint + " new State: " + gamerstate);
#endif
foreach (var gamer in session.RemoteGamers)
{
if (gamer.RemoteUniqueIdentifier == msg.SenderConnection.RemoteUniqueIdentifier)
{
gamer.State = gamerstate;
}
}
break;
case NetworkMessageType.SessionStateChange:
NetworkSessionState sessionState = (NetworkSessionState)msg.ReadInt32();
foreach (var gamer in session.RemoteGamers)
{
if (gamer.RemoteUniqueIdentifier == msg.SenderConnection.RemoteUniqueIdentifier)
{
#if !WINDOWS_PHONE
Game.Instance.Log("Session State change from: " + NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) +
" session is now: " + sessionState);
#endif
if (gamer.IsHost && sessionState == NetworkSessionState.Playing)
{
session.StartGame();
}
}
}
break;
}
break;
}
}
// sleep to allow other processes to run smoothly
// This may need to be changed depending on network throughput
Thread.Sleep(1);
if (worker.CancellationPending)
{
#if !WINDOWS_PHONE
Game.Instance.Log("worker CancellationPending");
#endif
e.Cancel = true;
done = true;
}
} while (!done);
}
static void Main(string[] args)
{
NetConfiguration config = new NetConfiguration("durable");
config.MaxConnections = 128;
config.Port = 14242;
NetServer server = new MyDurableServer(config);
server.SetMessageTypeEnabled(NetMessageType.ConnectionApproval, true);
server.SetMessageTypeEnabled(NetMessageType.DebugMessage, true);
//server.SetMessageTypeEnabled(NetMessageType.VerboseDebugMessage, true);
server.SetMessageTypeEnabled(NetMessageType.StatusChanged, true);
server.SimulatedMinimumLatency = 0.05f;
server.SimulatedLatencyVariance = 0.025f;
server.SimulatedLoss = 0.03f;
server.Start();
FileStream fs = new FileStream("./serverlog.txt", FileMode.Create, FileAccess.Write, FileShare.Read);
StreamWriter wrt = new StreamWriter(fs);
Output(wrt, "Log started at " + DateTime.Now);
wrt.Flush();
NetBuffer buffer = server.CreateBuffer();
int expected = 1;
Console.WriteLine("Press any key to quit");
while (!Console.KeyAvailable)
{
NetMessageType type;
NetConnection sender;
if (server.ReadMessage(buffer, out type, out sender))
{
switch (type)
{
case NetMessageType.StatusChanged:
string statusMessage = buffer.ReadString();
NetConnectionStatus newStatus = (NetConnectionStatus)buffer.ReadByte();
if (sender.RemoteHailData != null)
{
Output(wrt, "New status: " + newStatus + " (" + statusMessage + ") Remote hail is: " + Encoding.ASCII.GetString(sender.RemoteHailData));
}
else
{
Output(wrt, "New status: " + newStatus + " (" + statusMessage + ") Remote hail hasn't arrived.");
}
break;
case NetMessageType.BadMessageReceived:
case NetMessageType.ConnectionRejected:
case NetMessageType.DebugMessage:
//
// All these types of messages all contain a single string in the buffer; display it
//
Output(wrt, buffer.ReadString());
break;
case NetMessageType.VerboseDebugMessage:
wrt.WriteLine(buffer.ReadString()); // don't output to console
break;
case NetMessageType.ConnectionApproval:
if (sender.RemoteHailData != null &&
Encoding.ASCII.GetString(sender.RemoteHailData) == "Hail from client")
{
Output(wrt, "Hail ok!");
sender.Approve(Encoding.ASCII.GetBytes("Hail from server"));
}
else
{
sender.Disapprove("Wrong hail!");
}
break;
case NetMessageType.Data:
// verify ProcessReceived has done its work
int len = (int)buffer.Tag;
if (len != buffer.LengthBytes)
{
Output(wrt, "OUCH! ProcessReceived hasn't done its job!");
}
string str = buffer.ReadString();
// parse it
int nr = Int32.Parse(str.Substring(9));
if (nr != expected)
{
Output(wrt, "Warning! Expected " + expected + "; received " + nr + " str is ---" + str + "---");
}
else
{
expected++;
Console.Title = "Server; received " + nr + " messages";
}
break;
default:
Output(wrt, "Unhandled: " + type + " " + buffer.ToString());
break;
}
}
// we're not doing anything but reading; to suspend this thread until there's something to read
server.DataReceivedEvent.WaitOne(1000);
}
// clean shutdown
wrt.Close();
server.Shutdown("Application exiting");
System.Threading.Thread.Sleep(500); // give network thread time to exit
}
private void HandleMessages()
{
while (true)
{
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
server.SendDiscoveryResponse(null, msg.SenderEndPoint);
break;
case NetIncomingMessageType.ConnectionApproval:
if (msg.ReadByte() == (Byte)PacketTypes.ConnectionRequest)
{
//Game1.multiplayerLobbyTest.text += "\nclient connecting";
msg.SenderConnection.Approve();
}
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Game1.multiplayerLobbyTest.text += msg.ReadString();
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
//Console.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected!");
}
break;
case NetIncomingMessageType.Data:
switch (msg.ReadByte())
{
case (Byte)PacketTypes.PlayerLogin:
UpdatePlayerLogin(msg);
break;
case (Byte)PacketTypes.DiceConfiguration:
UpdateDiceConfiguration(msg);
break;
case (Byte)PacketTypes.GameStartSync:
NetOutgoingMessage outTrans = server.CreateMessage();
outTrans.Write((Byte)PacketTypes.GameStartSync);
server.SendToAll(outTrans, NetDeliveryMethod.ReliableOrdered);
break;
case (Byte)PacketTypes.Disconnecting:
NetOutgoingMessage discmsg = server.CreateMessage();
discmsg.Write((Byte)PacketTypes.Disconnecting);
server.SendToAll(discmsg, NetDeliveryMethod.ReliableOrdered);
break;
case (Byte)PacketTypes.MovesList:
Game1.multiplayerLobbyTest.text += "\ntransferring opponent moves list.";
NetOutgoingMessage outmsg = server.CreateMessage();
outmsg.Write((Byte)PacketTypes.MovesList);
int count = msg.ReadInt32();
outmsg.Write(count);
for (int i = 0; i < count; i++)
{
int selectedDiceID = msg.ReadInt32();
String selectedSpellName = msg.ReadString();
outmsg.Write(selectedDiceID);
outmsg.Write(selectedSpellName);
if (msg.ReadBoolean())
{
int targetedDiceID = msg.ReadInt32();
outmsg.Write(true);
outmsg.Write(targetedDiceID);
}
else
{
outmsg.Write(false);
}
outmsg.Write(msg.ReadVector2());
}
foreach (NetConnection con in server.Connections)
{
//Game1.multiplayerLobbyTest.text += con.Tag.ToString();
if (con != msg.SenderConnection)
{
server.SendMessage(outmsg, con, NetDeliveryMethod.ReliableOrdered);
//Game1.multiplayerLobbyTest.text += "\nsent msg";
}
}
break;
}
break;
default:
break;
}
}
Thread.Sleep(1);
}
}
private void OnHandleMessagesThread()
{
while (threadUpdate != null)
{
client.MessageReceivedEvent.WaitOne();
#if DEBUG
int nowTime = (int)(NetTime.Now * 1000);
if (nowTime - statsReset > 1000)
{
statsReset = nowTime;
Down = downLast;
Up = upLast;
downLast = 0;
upLast = 0;
}
#endif
NetIncomingMessage msg;
while (client.ReadMessage(out msg))
{
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
#if NETWORK_DEBUG
Console.ForegroundColor = ConsoleColor.DarkCyan;
Console.Write(" S ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine("[" + msg.SenderEndPoint + "] " + status);
#endif
if (status == NetConnectionStatus.Disconnected)
{
OnDisconnected?.Invoke();
}
break;
case NetIncomingMessageType.Data: {
#if DEBUG
downLast += msg.LengthBytes;
#endif
byte type = msg.ReadByte();
if (type == PacketTypes.UpdateAll)
{
OnUpdateAllPlayers?.Invoke(msg);
}
else
{
Action <NetIncomingMessage> callback;
if (callbacks.TryGetValue(type, out callback))
{
callback(msg);
}
else
{
Console.WriteLine(" - Unknown packet type (" + type + ")!");
}
}
break;
}
#if NETWORK_DEBUG
case NetIncomingMessageType.VerboseDebugMessage:
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.Write(" D ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.DebugMessage:
Console.ForegroundColor = ConsoleColor.Green;
Console.Write(" D ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(" W ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Console.ForegroundColor = ConsoleColor.Red;
Console.Write(" E ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(msg.ReadString());
break;
#endif
}
client.Recycle(msg);
}
}
client = null;
Debug.WriteLine("NetworkHandler: OnHandleMessagesThread exited!");
}
/// <summary>
/// Client message loop
/// </summary>
private void ClientLoop()
{
NetIncomingMessage msg;
while (this.IsRunning)
{
_server.MessageReceivedEvent.WaitOne(1000);
msg = _server.ReadMessage();
// If this second no messages accepted, releave CPU
if (msg == null)
{
continue;
}
try
{
switch (msg.MessageType)
{
// MESSAGETYPE: DATA
// The main message type in networking is the data type. When the connection is not linked, the
// data is the verification data of the handshake and will be processed accordingly. If not,
// the message is passed onto the Connection and processed by their respective protocol.
case NetIncomingMessageType.Data:
var connection = msg.SenderConnection.Tag as Connection;
if (connection != null)
{
// Client was authenticated so just process the message
connection.IncomingMessage(msg);
}
else
{
// Client is not yet authenticate so handle that. In my case we directly expect
// authentication, but you can write your own handling code. The following code
// handles just that.
var handshake = NetLobby.IncomingMessage(msg);
switch (handshake)
{
case Handshake.Contents.Succes:
Connection new_connection = new Connection(_server, msg.SenderConnection, (msg.SenderConnection.Tag as Handshake).CreateEncryption());
OnConnected.Invoke(new_connection.NodeId, new_connection.Username);
break;
case Handshake.Contents.Error:
case Handshake.Contents.Denied:
msg.SenderConnection.Disconnect("Error occured during handshake.");
break;
case Handshake.Contents.Expired:
msg.SenderConnection.Disconnect("Handshake expired.");
break;
}
}
break;
// MESSAGETYPE: CONNECTION APPROVAL
// The ConnectionApproval message type is seen when a node yields the peer#connect function. When
// the RemoteEndpoint specified is reached, a loose connection is made. It's up to the other end,
// the one that is connected too, to deny or approve the connection.
case NetIncomingMessageType.ConnectionApproval:
// Here you can add approval code to the public section of the server
msg.SenderConnection.Approve();
break;
// MESSAGETYPE: STATUS CHANGED
// Internal type that is triggered when a connection is initiated, responded too, connecting,
// disconnecting, connected or disconnected. Upon a connection, we might have received some
// RemoteHailData. This is part of the SRPP protocol and is proccesed accordingly. When
// disconnecting, the Connection is disposed, internal connection is disconnected and all is
// logged.
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus statusByte = (NetConnectionStatus)msg.ReadByte();
switch (statusByte)
{
case NetConnectionStatus.Disconnecting:
break;
case NetConnectionStatus.Disconnected:
// If already connection established, destroy resources
var disconnected_connection = msg.SenderConnection.Tag as Connection;
if (disconnected_connection != null)
{
OnDisconnected.Invoke(disconnected_connection.NodeId, disconnected_connection.Username);
if (!disconnected_connection.IsDisposed)
{
disconnected_connection.Dispose();
}
}
String finalReason = Encoding.UTF8.GetString(msg.ReadBytes((Int32)msg.ReadVariableUInt32()));
// Do something with the message if you want like logging: Received a reason for disconnecting...
break;
case NetConnectionStatus.Connected:
break;
default:
String statusChange = Encoding.UTF8.GetString(msg.ReadBytes((Int32)msg.ReadVariableUInt32()));
// You can log/debug status messages here
break;
}
break;
#if DEBUG
case NetIncomingMessageType.DebugMessage:
String debugMessage = Encoding.UTF8.GetString(msg.ReadBytes((Int32)msg.ReadVariableUInt32()));
// log
break;
#endif
case NetIncomingMessageType.WarningMessage:
String warningMessage = Encoding.UTF8.GetString(msg.ReadBytes((Int32)msg.ReadVariableUInt32()));
// log;
break;
case NetIncomingMessageType.ErrorMessage:
String errorMessage = Encoding.UTF8.GetString(msg.ReadBytes((Int32)msg.ReadVariableUInt32()));
// log
break;
default:
throw new NetException("MessageType: " + msg.MessageType + " is not supported.");
}
// Recycle please
_server.Recycle(msg);
}
catch (Exception e)
{
try
{
// Disconnect client on error
msg.SenderConnection.Disconnect("No tolerance: exception " + e.Message);
}
catch (Exception) { }
}
}
// Early shutdown
_server.Shutdown("Server shutting down");
Console.WriteLine("Client Service is Stopping at " + NetTime.ToReadable(NetTime.Now));
_server.Shutdown("Final shutdown");
}
public void Update()
{
if (client == null)
{
return;
}
NetIncomingMessage msg = null;
while (true)
{
// MH: someone may call Disconnect inside delegate, actually it should just poll events and then process them sequentially but Im lazu
if (client == null)
{
break;
}
msg = client.ReadMessage();
if (msg == null)
{
break;
}
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
{
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (clientDelegate != null)
{
if (status == NetConnectionStatus.Connected)
{
clientDelegate.OnClientConnected(this);
}
if (status == NetConnectionStatus.Disconnected)
{
clientDelegate.OnClientDisconnected(this);
}
}
}
break;
case NetIncomingMessageType.Data:
{
int msgid = msg.ReadInt32();
Message message = CreateMessageObject(msgid);
if (message == null)
{
Debug.LogError("Lidgren client: unknown message type received, did you forget to RegisterMessageType<T>() ?");
break;
}
if (clientDelegate != null)
{
message.id = msgid;
message.Read(msg);
clientDelegate.OnClientMessageReceived(this, message);
}
}
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
default:
break;
}
if (client != null)
{
client.Recycle(msg);
}
}
}
public abstract void ProcessStatusMessage(NetConnectionStatus status, string message);
/// <summary>
/// Initializes a new instance of the <see cref="ClientSocketManagerStatusChangedEventArgs"/> class.
/// </summary>
/// <param name="newStatus">The new <see cref="NetConnectionStatus"/>.</param>
/// <param name="reason">The reason for the status change.</param>
public ClientSocketManagerStatusChangedEventArgs(NetConnectionStatus newStatus, string reason)
{
_newStatus = newStatus;
_reason = reason;
}
void Handler()
{
NetIncomingMessage inmsg;
byte b;
Masterserver ms = null;
while (true)
{
while ((inmsg = server.ReadMessage()) != null)
{
switch (inmsg.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
//Console.WriteLine(inmsg.ReadString());
break;
//*************************************************************************
case NetIncomingMessageType.ConnectionApproval:
inmsg.SenderConnection.Approve();
lock (masterServers)
{
masterServers.Add(new Masterserver(inmsg.SenderConnection));
}
break;
//*************************************************************************
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)inmsg.ReadByte();
if (status == NetConnectionStatus.Disconnected)
{
lock (masterServers)
masterServers.RemoveAll(p => p.netConnection == inmsg.SenderConnection);
}
break;
//*************************************************************************
case NetIncomingMessageType.Data:
ms = masterServers.Find(p => p.netConnection == inmsg.SenderConnection);
if (ms == null || inmsg.LengthBytes < 1)
{
break;
}
b = inmsg.ReadByte();
//masterserver informs, if its enabled for hosting
if (b == 1)
{
Packet1(inmsg, ms);
}
//ms requests version
if (b == 2)
{
Packet2(inmsg);
}
//masterserver sends connection count to balanceserver
if (b == 21)
{
Packet21(inmsg, ms);
}
//timeout message
if (b == 84)
{
Packet84(inmsg, ms);
}
break;
//*************************************************************************
default:
Console.WriteLine("Unhandled type: " + inmsg.MessageType + " " + inmsg.LengthBytes + " bytes " + inmsg.DeliveryMethod + "|" + inmsg.SequenceChannel);
break;
}
server.Recycle(inmsg);
}
Thread.Sleep(1);
}
}
public void ProcessSockets()
{
Peer peer = null;
NetIncomingMessage im;
while ((im = PollMessage()) != null)
{
long id = long.MinValue;
if (im != null && im.SenderConnection != null)
{
id = im.SenderConnection.RemoteUniqueIdentifier;
}
peer = null;
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
AddLogLine(im.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
string reason = im.ReadString();
AddLogLine(NetUtility.ToHexString(im.SenderConnection.RemoteUniqueIdentifier) + " " + status + ": " + reason);
if (status == NetConnectionStatus.Connected)
{
lock (Locker)
Connected = true;
AddLogLine("Remote hail: " + im.SenderConnection.RemoteHailMessage.ReadString());
if (DefaultPeerHandler == null)
{
im.SenderConnection.Disconnect("Denied");
}
else
{
peer = DefaultPeerHandler.AddPeer(im);
lock (ConnectedPeers)
ConnectedPeers.Add(im.SenderConnection.RemoteUniqueIdentifier, peer);
}
}
else if (status == NetConnectionStatus.Disconnected)
{
peer = ConnectedPeers.ContainsKey(id) ? ConnectedPeers[id] : null;
if (peer == null) // not one of ours
{
return;
}
// tell our handler we poofed
if (peer.Handler != null)
{
peer.Handler.PeerDisconnected(reason, peer);
}
lock (ConnectedPeers)
{
Connected = ConnectedPeers.Count > 0;
ConnectedPeers.Remove(im.SenderConnection.RemoteUniqueIdentifier);
}
}
break;
case NetIncomingMessageType.Data:
peer = ConnectedPeers.ContainsKey(id) ? ConnectedPeers[id] : null;
if (peer == null || peer.Handler == null) // not one of ours
{
return;
}
// tell our handler we got some data
peer.Handler.PeerReceiveData(im, peer);
break;
default:
AddLogLine("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes " + im.DeliveryMethod + "|" + im.SequenceChannel);
break;
}
SocketServer.Recycle(im);
}
}
public void read()
{
while (client.Status == NetPeerStatus.Running && !ctSource.Token.IsCancellationRequested)
{
WaitHandle.WaitAny(new WaitHandle[] { client.MessageReceivedEvent, ctSource.Token.WaitHandle });
NetIncomingMessage im;
while ((im = client.ReadMessage()) != null && !ctSource.IsCancellationRequested)
{
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.Data:
try
{
if (alg != null)
{
im.Decrypt(alg);
}
MemoryStream ms = new MemoryStream(im.Data);
ProtoMessage m = null;
try
{
m = Serializer.DeserializeWithLengthPrefix <ProtoMessage>(ms, PrefixStyle.Fixed32);
}
catch (Exception e)
{
// Attempt to read string and add to message queue
string s = im.ReadString();
if (!string.IsNullOrWhiteSpace(s))
{
Console.WriteLine("CLIENT: Got message: " + s);
tClient.stringMessageQueue.Enqueue(s);
}
}
if (m != null)
{
Console.WriteLine("CLIENT: Got ProtoMessage with ActionType: " + m.ActionType + " and response type: " + m.ResponseType);
if (m.ResponseType == DisplayMessages.LogInSuccess)
{
loggedIn = true;
tClient.protobufMessageQueue.Enqueue(m);
}
else
{
if (m.ActionType == Actions.Update)
{
// Don't do anything at the moment for updates
}
else
{
tClient.protobufMessageQueue.Enqueue(m);
if (m.ActionType == Actions.LogIn && m.ResponseType == DisplayMessages.None)
{
byte[] key = null;
if (ValidateCertificateAndCreateKey(m as ProtoLogIn, out key))
{
ComputeAndSendHashAndKey(m as ProtoLogIn, key);
}
}
else
{
// Attempt to read string and add to message queue
string s = im.ReadString();
if (!string.IsNullOrWhiteSpace(s))
{
tClient.stringMessageQueue.Enqueue(s);
}
}
}
}
}
}
catch (Exception e)
{
Globals_Server.logError("Error in reading data: " + e.GetType() + " :" + e.Message + "; Stack Trace: " + e.StackTrace);
}
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
Console.WriteLine("CLIENT: Status changed to " + status.ToString());
//MemoryStream ms2 = new MemoryStream(im.SenderConnection.RemoteHailMessage.Data);
if (status == NetConnectionStatus.Connected)
{
if (im.SenderConnection.RemoteHailMessage != null)
{
try
{
MemoryStream ms2 = new MemoryStream(im.SenderConnection.RemoteHailMessage.Data);
ProtoMessage m = Serializer.DeserializeWithLengthPrefix <ProtoMessage>(ms2, PrefixStyle.Fixed32);
if (m != null)
{
tClient.protobufMessageQueue.Enqueue(m);
if (m.ActionType == Actions.LogIn && m.ResponseType == DisplayMessages.None)
{
byte[] key = null;
if (ValidateCertificateAndCreateKey(m as ProtoLogIn, out key))
{
if (autoLogIn)
{
ComputeAndSendHashAndKey(m as ProtoLogIn, key);
}
}
else
{
Console.WriteLine("Certificate validation failed: Server may be untrusted");
client.Disconnect("Invalid Certificate");
}
}
}
}
catch (Exception e)
{
}
}
break;
}
else if (status == NetConnectionStatus.Disconnected)
{
string reason = im.ReadString();
if (!string.IsNullOrEmpty(reason))
{
tClient.stringMessageQueue.Enqueue(reason);
}
}
if (im.SenderConnection.RemoteHailMessage != null && (NetConnectionStatus)im.ReadByte() == NetConnectionStatus.Connected)
{
}
break;
case NetIncomingMessageType.ConnectionLatencyUpdated:
break;
default:
break;
}
client.Recycle(im);
}
}
#if DEBUG
Globals_Server.logEvent("Client listening thread ends");
#endif
}
public ClientStatusChangedEventArgs(NetConnection connection, NetConnectionStatus status)
{
SenderConnection = connection;
Status = status;
}
/// <summary>
///
/// </summary>
public void Loop()
{
try
{
// This is checked each cycle
while (this.IsRunning)
{
_client.MessageReceivedEvent.WaitOne(1000);
NetIncomingMessage msg = _client.ReadMessage();
// No message received, please relieve CPU
if (msg == null)
{
continue;
}
switch (msg.MessageType)
{
case NetIncomingMessageType.Data:
if (msg.SenderConnection.Tag is Connection)
{
((Connection)msg.SenderConnection.Tag).IncomingMessage(msg);
}
else
{
NetLobby.IncomingMessage(msg);
}
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus statusByte = (NetConnectionStatus)msg.ReadByte();
switch (statusByte)
{
case NetConnectionStatus.Disconnecting:
break;
// When disconnect is called and processed
case NetConnectionStatus.Disconnected:
// If already connection established, destroy resources
if (msg.SenderConnection.Tag is Connection &&
!((Connection)msg.SenderConnection.Tag).IsDisposed)
{
((Connection)msg.SenderConnection.Tag).Dispose();
}
// Received a reason for disconnecting? (e.a. Handshake Fail)
String finalReason = Encoding.UTF8.GetString(msg.ReadBytes((Int32)msg.ReadVariableUInt32()));
// Some exceptions that should be catched but even so
if (finalReason.StartsWith("Handshake data validation failed"))
{
SetStep(AuthenticationStatus.NoServerConnection);
OnAuthenticationFailed.Invoke("Could not connect");
}
else if (finalReason.StartsWith("Failed to establish"))
{
SetStep(AuthenticationStatus.NoServerConnection);
OnAuthenticationTimeout.Invoke("Could not connect");
}
Disconnect("");
break;
case NetConnectionStatus.Connected:
SetStep(AuthenticationStatus.ServerConnection);
var username = _username;
var password = _password;
// Connected so lets start authenticating
Authenticate(_client.ServerConnection, _username, _password);
break;
}
break;
}
}
Disconnect("");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public StatusMessageArgs(NetConnectionStatus status, String reason)
{
Status = status;
Reason = reason;
}
public override void ProcessStatusMessage(NetConnectionStatus status, string message)
{
}
public void Update()
{
if (NetworkClient != null && NetworkClient.Status == NetPeerStatus.Running)
{
NetIncomingMessage msg;
while ((msg = NetworkClient.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
{
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
NetOutgoingMessage outMsg = NetworkClient.CreateMessage();
outMsg.Write((byte)CommandType.GetChannelInfo);
outMsg.Write(channelInfos[currentChannel].channelId);
NetworkClient.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
}
else if (status == NetConnectionStatus.Disconnected)
{
ChannelException?.Invoke(this, new Exception("Channel refused connection!"));
Abort();
}
};
break;
case NetIncomingMessageType.Data:
{
if ((CommandType)msg.ReadByte() == CommandType.GetChannelInfo)
{
ChannelInfo received = new ChannelInfo(msg);
if (received.channelId == -1)
{
ChannelException?.Invoke(this, new Exception($"Channel with ID {channelInfos[currentChannel].channelId} not found!"));
Abort();
return;
}
received.ip = channelInfos[currentChannel].ip;
received.port = channelInfos[currentChannel].port;
ReceivedResponse?.Invoke(this, received);
if (channelInfos.Count - 1 > currentChannel)
{
currentChannel++;
NetOutgoingMessage outMsg = NetworkClient.CreateMessage();
outMsg.Write((byte)CommandType.GetChannelInfo);
outMsg.Write(channelInfos[currentChannel].channelId);
NetworkClient.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
}
else
{
Abort();
}
}
};
break;
case NetIncomingMessageType.WarningMessage:
Plugin.log.Warn(msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Plugin.log.Error(msg.ReadString());
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
Plugin.log.Info(msg.ReadString());
break;
default:
Console.WriteLine("Unhandled type: " + msg.MessageType);
break;
}
}
}
}
private static void HubLoop(object sender, HighResolutionTimerElapsedEventArgs e)
{
if (_ticksLength.Count > 30)
{
_ticksLength.RemoveAt(0);
}
_ticksLength.Add(DateTime.UtcNow.Subtract(_lastTick).Ticks / (float)TimeSpan.TicksPerMillisecond);
_lastTick = DateTime.UtcNow;
List <RoomInfo> roomsList = RoomsController.GetRoomInfosList();
string titleBuffer = $"ServerHub v{Assembly.GetEntryAssembly().GetName().Version}: {roomsList.Count} rooms, {hubClients.Count} clients in lobby, {roomsList.Select(x => x.players).Sum() + hubClients.Count} clients total {(Settings.Instance.Server.ShowTickrateInTitle ? $", {Tickrate.ToString("0.0")} tickrate" : "")}";
if (_currentTitle != titleBuffer)
{
_currentTitle = titleBuffer;
Console.Title = _currentTitle;
}
List <Client> allClients = hubClients.Concat(RoomsController.GetRoomsList().SelectMany(x => x.roomClients)).Concat(RadioController.radioChannels.SelectMany(x => x.radioClients)).ToList();
NetIncomingMessage msg;
while (ListenerServer.ReadMessage(out msg))
{
try
{
Program.networkBytesInNow += msg.LengthBytes;
switch (msg.MessageType)
{
case NetIncomingMessageType.ConnectionApproval:
{
byte[] versionBytes = msg.PeekBytes(4);
byte[] version = msg.ReadBytes(4);
if (version[0] == 0 && version[1] == 0)
{
uint versionUint = BitConverter.ToUInt32(version, 0);
uint serverVersionUint = ((uint)Assembly.GetEntryAssembly().GetName().Version.Major).ConcatUInts((uint)Assembly.GetEntryAssembly().GetName().Version.Minor).ConcatUInts((uint)Assembly.GetEntryAssembly().GetName().Version.Build).ConcatUInts((uint)Assembly.GetEntryAssembly().GetName().Version.Revision);
msg.SenderConnection.Deny($"Version mismatch!\nServer:{serverVersionUint}\nClient:{versionUint}");
Logger.Instance.Log($"Client version v{versionUint} tried to connect");
break;
}
byte[] serverVersion = new byte[4] {
(byte)Assembly.GetEntryAssembly().GetName().Version.Major, (byte)Assembly.GetEntryAssembly().GetName().Version.Minor, (byte)Assembly.GetEntryAssembly().GetName().Version.Build, (byte)Assembly.GetEntryAssembly().GetName().Version.Revision
};
if (version[0] != serverVersion[0] || version[1] != serverVersion[1] || version[2] != serverVersion[2])
{
msg.SenderConnection.Deny($"Version mismatch|{string.Join('.', serverVersion)}|{string.Join('.', version)}");
Logger.Instance.Log($"Client version v{string.Join('.', version)} tried to connect");
break;
}
PlayerInfo playerInfo = new PlayerInfo(msg);
if (Settings.Instance.Access.WhitelistEnabled)
{
if (!IsWhitelisted(msg.SenderConnection.RemoteEndPoint, playerInfo))
{
msg.SenderConnection.Deny("You are not whitelisted on this ServerHub!");
Logger.Instance.Warning($"Client {playerInfo.playerName}({playerInfo.playerId})@{msg.SenderConnection.RemoteEndPoint.Address} is not whitelisted!");
break;
}
}
if (IsBlacklisted(msg.SenderConnection.RemoteEndPoint, playerInfo))
{
msg.SenderConnection.Deny("You are banned on this ServerHub!");
Logger.Instance.Warning($"Client {playerInfo.playerName}({playerInfo.playerId})@{msg.SenderConnection.RemoteEndPoint.Address} is banned!");
break;
}
msg.SenderConnection.Approve();
Client client = new Client(msg.SenderConnection, playerInfo);
client.playerInfo.updateInfo.playerState = PlayerState.Lobby;
client.ClientDisconnected += ClientDisconnected;
hubClients.Add(client);
allClients.Add(client);
Logger.Instance.Log($"{playerInfo.playerName} connected!");
};
break;
case NetIncomingMessageType.Data:
{
Client client = allClients.FirstOrDefault(x => x.playerConnection.RemoteEndPoint.Equals(msg.SenderEndPoint));
switch ((CommandType)msg.ReadByte())
{
case CommandType.Disconnect:
{
if (client != null)
{
allClients.Remove(client);
ClientDisconnected(client);
}
}
break;
case CommandType.UpdatePlayerInfo:
{
if (client != null)
{
if (msg.PeekByte() == 1 || !client.lastUpdateIsFull)
{
client.UpdatePlayerInfo(msg);
}
if (Settings.Instance.Misc.PlayerColors.ContainsKey(client.playerInfo.playerId))
{
client.playerInfo.updateInfo.playerNameColor = Settings.Instance.Misc.PlayerColors[client.playerInfo.playerId];
}
}
}
break;
case CommandType.UpdateVoIPData:
{
if (!Settings.Instance.Server.AllowVoiceChat)
{
return;
}
if (client != null)
{
UnityVOIP.VoipFragment data = new UnityVOIP.VoipFragment(msg);
if (data.playerId == client.playerInfo.playerId)
{
client.playerVoIPQueue.Enqueue(data);
}
}
}
break;
case CommandType.JoinRoom:
{
if (client != null)
{
uint roomId = msg.ReadUInt32();
BaseRoom room = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == roomId);
if (room != null)
{
if (room.roomSettings.UsePassword)
{
if (RoomsController.ClientJoined(client, roomId, msg.ReadString()))
{
if (hubClients.Contains(client))
{
hubClients.Remove(client);
}
client.joinedRoomID = roomId;
}
}
else
{
if (RoomsController.ClientJoined(client, roomId, ""))
{
if (hubClients.Contains(client))
{
hubClients.Remove(client);
}
client.joinedRoomID = roomId;
}
}
}
else
{
RoomsController.ClientJoined(client, roomId, "");
}
}
}
break;
case CommandType.LeaveRoom:
{
if (client != null)
{
RoomsController.ClientLeftRoom(client);
client.joinedRoomID = 0;
client.playerInfo.updateInfo.playerState = PlayerState.Lobby;
if (!hubClients.Contains(client))
{
hubClients.Add(client);
}
}
}
break;
case CommandType.GetRooms:
{
NetOutgoingMessage outMsg = ListenerServer.CreateMessage();
outMsg.Write((byte)CommandType.GetRooms);
RoomsController.AddRoomListToMessage(outMsg);
msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
Program.networkBytesOutNow += outMsg.LengthBytes;
}
break;
case CommandType.CreateRoom:
{
if (client != null)
{
uint roomId = RoomsController.CreateRoom(new RoomSettings(msg), client.playerInfo);
NetOutgoingMessage outMsg = ListenerServer.CreateMessage(5);
outMsg.Write((byte)CommandType.CreateRoom);
outMsg.Write(roomId);
msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
Program.networkBytesOutNow += outMsg.LengthBytes;
}
}
break;
case CommandType.GetRoomInfo:
{
if (client != null)
{
#if DEBUG
Logger.Instance.Log("GetRoomInfo: Client room=" + client.joinedRoomID);
#endif
if (client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
NetOutgoingMessage outMsg = ListenerServer.CreateMessage();
outMsg.Write((byte)CommandType.GetRoomInfo);
joinedRoom.GetRoomInfo().AddToMessage(outMsg);
msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
Program.networkBytesOutNow += outMsg.LengthBytes;
}
}
}
}
break;
case CommandType.SetSelectedSong:
{
if (client != null && client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
if (msg.LengthBytes < 16)
{
joinedRoom.SetSelectedSong(client.playerInfo, null);
}
else
{
joinedRoom.SetSelectedSong(client.playerInfo, new SongInfo(msg));
}
}
}
}
break;
case CommandType.SetLevelOptions:
{
if (client != null && client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
joinedRoom.SetLevelOptions(client.playerInfo, new LevelOptionsInfo(msg));
}
}
}
break;
case CommandType.StartLevel:
{
#if DEBUG
Logger.Instance.Log("Received command StartLevel");
#endif
if (client != null && client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
LevelOptionsInfo options = new LevelOptionsInfo(msg);
SongInfo song = new SongInfo(msg);
song.songDuration += 2.5f;
joinedRoom.StartLevel(client.playerInfo, options, song);
}
}
}
break;
case CommandType.DestroyRoom:
{
if (client != null && client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
joinedRoom.DestroyRoom(client.playerInfo);
}
}
}
break;
case CommandType.TransferHost:
{
if (client != null && client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
joinedRoom.TransferHost(client.playerInfo, new PlayerInfo(msg));
}
}
}
break;
case CommandType.PlayerReady:
{
if (client != null && client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
joinedRoom.ReadyStateChanged(client.playerInfo, msg.ReadBoolean());
}
}
}
break;
case CommandType.SendEventMessage:
{
if (client != null && client.joinedRoomID != 0 && Settings.Instance.Server.AllowEventMessages)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
string header = msg.ReadString();
string data = msg.ReadString();
joinedRoom.BroadcastEventMessage(header, data, new List <Client>()
{
client
});
joinedRoom.BroadcastWebSocket(CommandType.SendEventMessage, new EventMessage(header, data));
EventMessageReceived?.Invoke(client, header, data);
#if DEBUG
Logger.Instance.Log($"Received event message! Header=\"{header}\", Data=\"{data}\"");
#endif
}
}
}
break;
case CommandType.GetChannelInfo:
{
if (Settings.Instance.Radio.EnableRadio && RadioController.radioStarted)
{
int channelId = msg.ReadInt32();
NetOutgoingMessage outMsg = ListenerServer.CreateMessage();
outMsg.Write((byte)CommandType.GetChannelInfo);
if (RadioController.radioChannels.Count > channelId)
{
RadioController.radioChannels[channelId].channelInfo.AddToMessage(outMsg);
}
else
{
new ChannelInfo()
{
channelId = -1, currentSong = new SongInfo()
{
levelId = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
}
}.AddToMessage(outMsg);
}
msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
Program.networkBytesOutNow += outMsg.LengthBytes;
}
}
break;
case CommandType.JoinChannel:
{
int channelId = msg.ReadInt32();
NetOutgoingMessage outMsg = ListenerServer.CreateMessage();
outMsg.Write((byte)CommandType.JoinChannel);
if (RadioController.ClientJoinedChannel(client, channelId))
{
outMsg.Write((byte)0);
hubClients.Remove(client);
}
else
{
outMsg.Write((byte)1);
}
msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
Program.networkBytesOutNow += outMsg.LengthBytes;
}
break;
case CommandType.GetSongDuration:
{
foreach (RadioChannel channel in RadioController.radioChannels)
{
if (channel.radioClients.Contains(client) && channel.requestingSongDuration)
{
SongInfo info = new SongInfo(msg);
if (info.levelId == channel.channelInfo.currentSong.levelId)
{
channel.songDurationResponses.TryAdd(client, info.songDuration);
}
}
}
}
break;
case CommandType.LeaveChannel:
{
if (RadioController.radioStarted && client != null)
{
RadioController.ClientLeftChannel(client);
}
}; break;
}
};
break;
case NetIncomingMessageType.WarningMessage:
Logger.Instance.Warning(msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Logger.Instance.Error(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
{
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
Client client = allClients.FirstOrDefault(x => x.playerConnection.RemoteEndPoint.Equals(msg.SenderEndPoint));
if (client != null)
{
if (status == NetConnectionStatus.Disconnected)
{
allClients.Remove(client);
ClientDisconnected(client);
}
}
}
break;
#if DEBUG
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
Logger.Instance.Log(msg.ReadString());
break;
default:
Logger.Instance.Log("Unhandled message type: " + msg.MessageType);
break;
#endif
}
}catch (Exception ex)
{
Logger.Instance.Log($"Exception on message received: {ex}");
}
ListenerServer.Recycle(msg);
}
}
internal void NotifyStatusChange(NetConnection conn, NetConnectionStatus previousStatus, string reason)
{
if (StatusChanged != null)
{
NetStatusEventArgs e = new NetStatusEventArgs();
e.PreviousStatus = previousStatus;
e.Connection = conn;
e.Reason = reason;
StatusChanged(this, e);
}
}
public static void GotMessage(object peer)
{
var server = (CServer)peer;
var msg = server.ReadMessage();
switch (msg.MessageType)
{
case NetIncomingMessageType.Error:
string errorText;
bool worked = msg.ReadString(out errorText);
Main.Log("[SERVER ERROR] " + (worked ? errorText : "(???)"));
break;
case NetIncomingMessageType.StatusChanged:
byte b = msg.ReadByte();
string statusText = msg.ReadString();
NetConnectionStatus status = (NetConnectionStatus)b;
Main.Log("[STATUS UPDATE] " + status + " - " + statusText);
if (status == NetConnectionStatus.Disconnected)
{
string n = server.GetUsername(msg.SenderConnection);
if (n != null)
{
Main.Log("User '" + n + "' has disconnected from the server. Cya!");
server.SetName(msg.SenderConnection, null);
Main.RemoveUser(n);
var removeNameMsg = server.CreateMessage();
removeNameMsg.Write((byte)DataType.NAME);
removeNameMsg.Write(1);
removeNameMsg.Write(false);
removeNameMsg.Write(n);
server.SendToAll(removeNameMsg, NetDeliveryMethod.ReliableUnordered);
}
}
if (status == NetConnectionStatus.Connected)
{
// Send the names of all connected people.
var outMsg = server.CreateMessage();
outMsg.Write((byte)DataType.NAME);
outMsg.Write(server.names.Count + 1);
foreach (var item in server.names)
{
outMsg.Write(true);
outMsg.Write(item.Value);
}
outMsg.Write(true);
outMsg.Write(Main.ActiveUsername);
server.SendMessage(outMsg, msg.SenderConnection, NetDeliveryMethod.ReliableUnordered);
// Tell everyone else that this person joined...
var outMsg2 = server.CreateMessage();
outMsg2.Write((byte)DataType.NAME);
outMsg2.Write(1);
outMsg2.Write(true);
outMsg2.Write(server.GetUsername(msg.SenderConnection));
server.SendToAll(outMsg2, msg.SenderConnection, NetDeliveryMethod.ReliableUnordered, 0);
}
break;
case NetIncomingMessageType.Data:
// Find the type.
var type = (DataType)msg.ReadByte();
ProcessData(type, msg, server);
break;
case NetIncomingMessageType.DiscoveryRequest:
NetOutgoingMessage response = server.CreateMessage(server.Name);
server.SendDiscoveryResponse(response, msg.SenderEndPoint);
break;
case NetIncomingMessageType.WarningMessage:
Main.Log("[SERVER WARNING] " + msg.ReadString());
break;
case NetIncomingMessageType.ConnectionApproval:
string name = msg.ReadString().Trim();
if (server.names.ContainsValue(name) || Main.ActiveUsername == name)
{
msg.SenderConnection.Deny("Somebody else on the server already has your username.");
Main.Log("Rejected connection from " + msg.SenderConnection + " because they have a duplicate username: "******"Approved connection from " + msg.SenderConnection.RemoteEndPoint + ", called '" + name + "', and sent the current names. (" + (server.names.Count + 1) + ")");
}
break;
default:
Main.Log("[SERVER UNHANDLED] Type: " + msg.MessageType);
break;
}
server.Recycle(msg);
}
private void IOHandler()
{
while (m_Status == RoomSrvStatus.STATUS_RUNNING)
{
try {
m_NetServer.MessageReceivedEvent.WaitOne(1000);
long startTime = TimeUtility.GetElapsedTimeUs();
NetIncomingMessage im;
for (int ct = 0; ct < 1024; ++ct)
{
try {
if ((im = m_NetServer.ReadMessage()) != null)
{
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
LogSys.Log(LOG_TYPE.DEBUG, "Debug Message: {0}", im.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
LogSys.Log(LOG_TYPE.DEBUG, "Error Message: {0}", im.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
LogSys.Log(LOG_TYPE.DEBUG, "Warning Message: {0}", im.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
string reason = im.ReadString();
if (null != im.SenderConnection)
{
RoomPeer peer = RoomPeerMgr.Instance.GetPeerByConnection(im.SenderConnection);
if (null != peer)
{
LogSys.Log(LOG_TYPE.DEBUG, "Network Status Changed: {0} reason:{1} EndPoint:{2} Key:{3} User:{4}\nStatistic:{5}", status, reason, im.SenderEndPoint.ToString(), peer.GetKey(), peer.Guid, im.SenderConnection.Statistics.ToString());
}
else
{
LogSys.Log(LOG_TYPE.DEBUG, "Network Status Changed: {0} reason:{1} EndPoint:{2}\nStatistic:{3}", status, reason, im.SenderEndPoint.ToString(), im.SenderConnection.Statistics.ToString());
}
}
else
{
LogSys.Log(LOG_TYPE.DEBUG, "Network Status Changed:{0} reason:{1}", status, reason);
}
break;
case NetIncomingMessageType.Data:
int id = 0;
object msg = null;
byte[] data = null;
try {
data = im.ReadBytes(im.LengthBytes);
msg = Serialize.Decode(data, out id);
} catch {
if (null != im.SenderConnection)
{
RoomPeer peer = RoomPeerMgr.Instance.GetPeerByConnection(im.SenderConnection);
if (null != peer)
{
LogSys.Log(LOG_TYPE.WARN, "room server decode message error !!! from User:{0}({1})", peer.Guid, peer.GetKey());
}
}
}
if (msg != null)
{
m_Dispatch.Dispatch(id, msg, im.SenderConnection);
}
else
{
if (null != im.SenderConnection)
{
RoomPeer peer = RoomPeerMgr.Instance.GetPeerByConnection(im.SenderConnection);
if (null != peer)
{
LogSys.Log(LOG_TYPE.DEBUG, "got unknow message !!! from User:{0}({1})", peer.Guid, peer.GetKey());
}
else
{
LogSys.Log(LOG_TYPE.DEBUG, "got unknow message !!!");
}
}
else
{
LogSys.Log(LOG_TYPE.DEBUG, "got unknow message !!!");
}
}
break;
default:
break;
}
m_NetServer.Recycle(im);
}
else
{
break;
}
} catch (Exception ex) {
LogSys.Log(LOG_TYPE.ERROR, "Exception {0}\n{1}", ex.Message, ex.StackTrace);
}
}
RoomPeerMgr.Instance.Tick();
long endTime = TimeUtility.GetElapsedTimeUs();
if (endTime - startTime >= 10000)
{
LogSys.Log(LOG_TYPE.DEBUG, "Warning, IOHandler() cost {0} us !\nNetPeer Statistic:{1}", endTime - startTime, m_NetServer.Statistics.ToString());
}
} catch (Exception ex) {
LogSys.Log(LOG_TYPE.ERROR, "Exception {0}\n{1}", ex.Message, ex.StackTrace);
}
Thread.Sleep(10);
}
}
private void ProcessNetworkMessages()
{
NetIncomingMessage inc;
while ((inc = client.ReadMessage()) != null)
{
switch (inc.MessageType)
{
//Report changes in connection status
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)inc.ReadByte();
switch (status)
{
case NetConnectionStatus.Connected:
/*var message = new UpdatePlayerStateMessage(inc.SenderConnection.RemoteHailMessage);
* this.playerManager.AddPlayer(message.Id, message.Position, message.Velocity, message.Rotation, true);
* Console.WriteLine("Connected to {0}", inc.SenderEndPoint);*/
ConnectionSuccess("Connected to " + inc.SenderEndpoint);
break;
case NetConnectionStatus.Disconnected:
if (Entry.UserInterace != null && Entry.UserInterace.Chat != null)
{
Entry.UserInterace.Chat.Log("Lost connection to the server !");
}
string reason = "Unknown error !";
try
{
inc.ReadByte();
reason = inc.ReadString();
}
catch { }
ConnectionFailed(reason);
break;
case NetConnectionStatus.Disconnecting:
case NetConnectionStatus.InitiatedConnect:
case NetConnectionStatus.RespondedConnect:
Console.WriteLine(status.ToString());
break;
}
break;
case NetIncomingMessageType.ConnectionApproval:
break;
case NetIncomingMessageType.Data:
handler.Handle(inc);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(inc.ReadString());
break;
}
client.Recycle(inc);
}
}
/// <summary>
/// Recebe os dados dos clientes.
/// </summary>
public static void ReceivedData()
{
NetIncomingMessage msg;
while ((msg = Socket.ReadMessage()) != null)
{
var pData = Authentication.FindByConnection(msg.SenderConnection);
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
#region Find Banned IP
if (Accounts_DB.BannedIP(msg.SenderEndPoint.Address.ToString()) == true)
{
LogConfig.WriteLog("Warning: Attempted IP Banned " + msg.SenderEndPoint.Address);
LogConfig.WriteLog("Warning: Attempted IP Banned " + msg.SenderEndPoint.Address, Color.Coral);
return;
}
#endregion
LoginServerNetwork.Socket.SendDiscoveryResponse(null, msg.SenderEndPoint);
LogConfig.WriteLog($"Discovery Response IPEndPoint: {msg.SenderEndPoint.Address}", Color.Coral);
break;
case NetIncomingMessageType.ErrorMessage:
LogConfig.WriteLog($"Error: {msg.ReadString()}", Color.Coral);
break;
case NetIncomingMessageType.StatusChanged:
#region Status Changed Connected
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
LogConfig.WriteLog($"Status changed to connected: {msg.SenderEndPoint.Address}", Color.Coral);
Authentication.Player.Add(new PlayerData(msg.SenderConnection, NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier), msg.SenderEndPoint.Address.ToString()));
}
#endregion
#region Status Changed Disconnected
if (status == NetConnectionStatus.Disconnected)
{
pData = Authentication.FindByHexID(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier));
//1 - enabled, 0 - disabled
if (Settings.LogSystem == 1)
{
LogConfig.WriteLog($"Status changed to disconnected: {pData?.ID} {pData?.Account} {msg.SenderEndPoint.Address} {pData.HexID}");
}
if (!Settings.LogSystemScreen)
{
LogConfig.WriteLog($"Status changed to disconnected: {pData?.ID} {pData?.Account} {msg.SenderEndPoint.Address} {pData.HexID}", Color.Coral);
}
Accounts_DB.UpdateLastIP(pData.Account, pData.IP);
Accounts_DB.UpdateLoggedIn(pData.Account, 0); //0 disconnect
Accounts_DB.UpdateCurrentIP(pData.Account, "");
Authentication.Player.Remove(pData);
}
#endregion
break;
case NetIncomingMessageType.Data:
LoginServerData.HandleData(pData.HexID, msg);
break;
default:
//Registra qualquer mensagem invalida
LogConfig.WriteLog($"Unhandled type: {msg.MessageType}", Color.DarkRed);
break;
}
LoginServerNetwork.Socket.Recycle(msg);
}
}
private Task RunListenerAsync()
{
return(Task.Factory.StartNew(() =>
{
while (!_cancelTokenSource.IsCancellationRequested)
{
NetIncomingMessage im;
while ((im = _server.ReadMessage()) != null)
{
// handle incoming message
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
string text = im.ReadString();
Output(text);
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
string reason = im.ReadString();
Output(NetUtility.ToHexString(im.SenderConnection.RemoteUniqueIdentifier) + " " + status + ": " + reason);
UpdateConnectionsList(im.SenderConnection, status);
break;
case NetIncomingMessageType.Data:
string data = im.ReadString();
KeyValue <string> x = new KeyValue <string>(data);
Output("data from client - key:" + x.key + " value:" + x.value);
//= _jSerializer.Deserialize<Tuple<string, string>>(data);
// incoming chat message from a client
//string chat = im.ReadString();
//Output("Broadcasting '" + chat + "'");
//// broadcast this to all connections, except sender
//List<NetConnection> all = _server.Connections; // get copy
//all.Remove(im.SenderConnection);
//if (all.Count > 0)
//{
// NetOutgoingMessage om = _server.CreateMessage();
// om.Write(NetUtility.ToHexString(im.SenderConnection.RemoteUniqueIdentifier) + " said: " + chat);
// _server.SendMessage(om, all, NetDeliveryMethod.ReliableOrdered, 0);
//}
break;
default:
Output("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes " + im.DeliveryMethod + "|" + im.SequenceChannel);
break;
}
_server.Recycle(im);
}
Thread.Sleep(1);
}
}
));
}
static void Update()
{
if (!isMessageQueueRunning) return;
List<NetIncomingMessage> messages = new List<NetIncomingMessage>();
int counter = peer.ReadMessages(messages);
foreach (var msg in messages)
{
//faster than switch, as most will be Data messages.
if (msg.MessageType == NetIncomingMessageType.Data)
{
Consume(msg);
peer.Recycle(msg);
}
else if (msg.MessageType == NetIncomingMessageType.DiscoveryResponse)
{
if (OnDiscoveryResponse != null) OnDiscoveryResponse(msg);
peer.Recycle(msg);
}
else if (msg.MessageType == NetIncomingMessageType.WarningMessage)
{
Debug.LogWarning(msg.ReadString());
peer.Recycle(msg);
}
else if (msg.MessageType == NetIncomingMessageType.ConnectionLatencyUpdated)
{
Latency = msg.ReadFloat();
peer.Recycle(msg);
}
else if (msg.MessageType == NetIncomingMessageType.ErrorMessage)
{
Debug.LogError(msg.ReadString());
peer.Recycle(msg);
}
else if (msg.MessageType == NetIncomingMessageType.StatusChanged)
{
var lastStatus = m_status;
m_status = (NetConnectionStatus)msg.ReadByte();
statusReason = msg.ReadString();
peer.Recycle(msg);
try
{
if (m_status == NetConnectionStatus.Disconnected)
{
if (lastStatus != NetConnectionStatus.Disconnected)
{
if (OnDisconnectedFromServer != null)
OnDisconnectedFromServer();
if (Configuration.DeleteNetworkInstantiatesOnDisconnect)
{
NetworkView.DestroyAllViews();
}
}
else
{
if (OnFailedToConnect != null)
OnFailedToConnect(statusReason);
}
}
else if (m_status == NetConnectionStatus.Connected)
{
if (OnConnectedToServer != null)
OnConnectedToServer();
}
}
catch (Exception e)
{
Debug.LogError(e);
}
}
else if (msg.MessageType == NetIncomingMessageType.Error)
{
Debug.LogError(msg.ReadString()); //this should really never happen...
peer.Recycle(msg);
}
else
peer.Recycle(msg);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ClientSocketManagerStatusChangedEventArgs"/> class.
/// </summary>
/// <param name="newStatus">The new <see cref="NetConnectionStatus"/>.</param>
/// <param name="reason">The reason for the status change.</param>
public ClientSocketManagerStatusChangedEventArgs(NetConnectionStatus newStatus, string reason)
{
_newStatus = newStatus;
_reason = reason;
}
public override void StatusChanged(NetConnectionStatus status, string message, NetConnection connection)
{
}
public StatusMessageArgs(NetConnectionStatus status, String reason)
{
Status = status;
Reason = reason;
}
public void SetStatus(NetConnectionStatus status, string reason)
{
if (m_status == status)
{
m_parent.Log.Warning("Redundant status change: " + status);
return;
}
NetConnectionStatus wasStatus = m_status;
m_status = status;
m_parent.NotifyStatusChange(this, wasStatus, reason);
if (m_status == NetConnectionStatus.Connected)
m_savedConnectCustomData = null; // no need to hang on to this now
if (m_status == NetConnectionStatus.Disconnected)
{
NetServer server = m_parent as NetServer;
if (server != null)
server.RemoveConnection(this);
}
}
/// <summary>
/// When overridden in the derived class, allows for handling when the status of an <see cref="IIPSocket"/> changes.
/// </summary>
/// <param name="sender">The <see cref="IIPSocket"/> who's status has changed.</param>
/// <param name="status">The new status.</param>
/// <param name="reason">The reason for the status change.</param>
protected virtual void OnReceiveStatusChanged(IIPSocket sender, NetConnectionStatus status, string reason)
{
}
public abstract void OnStatusChange(NetConnection connection, NetConnectionStatus status);
public static void GotMessage(object peer)
{
NetIncomingMessage im;
while ((im = Program.s_client.ReadMessage()) != null)
{
// handle incoming message
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
string text = im.ReadString();
//Output(text);
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
if (status == NetConnectionStatus.Connected)
{
L_form.EnableInput();
Output("Successfully connected to Chat");
}
else
{
//s_form.DisableInput();
//s_form.ReConnect();
//string reason = im.ReadString();
//Output(status.ToString() + ": " + reason);
}
break;
case NetIncomingMessageType.Data:
string chat = im.ReadString();
if (chat.StartsWith("PlayersIn"))
{
string[] chat2 = chat.Split(':');
string[] PlayersInLobby = chat2[0].Split(';');
string[] PlayersInGame = chat2[1].Split(';');
L_form.FillList(PlayersInLobby, PlayersInGame);
//L_form.PlayersInLobbyList.View = View.Details;
}
else if (chat == "kick:" + Program.game.LocalPlayerGuid.ToString())
{
System.Windows.Forms.MessageBox.Show("You were kicked by the Admin!");
L_form.LobbyForm_FormClosing(null, null);
}
else if (chat == "ban:" + Program.game.LocalPlayerGuid.ToString())
{
System.Windows.Forms.MessageBox.Show("You were banned by the Admin!");
L_form.LobbyForm_FormClosing(null, null);
}
else
{
Output(chat);
}
break;
default:
Output("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes");
break;
}
}
}
public LidgrenStatusMessage(NetConnectionStatus status)
{
Status = status.ToGladNet();
}
private void OnRecvMessage()
{
try {
m_NetClient.MessageReceivedEvent.WaitOne(1000);
NetIncomingMessage im;
while ((im = m_NetClient.ReadMessage()) != null)
{
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
LogSystem.Info("Debug Message: {0}", im.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
LogSystem.Info("Error Message: {0}", im.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
LogSystem.Info("Warning Message: {0}", im.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
string reason = im.ReadString();
if (null != im.SenderConnection)
{
LogSystem.Info("Network Status Changed:{0} Reason:{1}\nStatistic:{2}", status, reason, im.SenderConnection.Statistics.ToString());
LogMessageCount();
if (NetConnectionStatus.Disconnected == status)
{
m_IsConnected = false;
m_CanSendMessage = false;
if (reason.CompareTo("disconnect") == 0)
{
if (!m_IsWaitStart)
{
m_IsWaitStart = true;
m_NetClient.Disconnect("bye for disconnect");
PluginFramework.Instance.QueueAction(this.OnRoomServerWaitStart);
}
}
}
else if (NetConnectionStatus.Connected == status)
{
OnConnected(im.SenderConnection);
}
}
else
{
LogSystem.Info("Network Status Changed:{0} reason:{1}", status, reason);
}
break;
case NetIncomingMessageType.Data:
case NetIncomingMessageType.UnconnectedData:
if (!m_IsConnected && NetIncomingMessageType.Data == im.MessageType)
{
break;
}
try {
byte[] data = im.ReadBytes(im.LengthBytes);
int id;
object msg = Serialize.Decode(data, out id);
if (msg != null)
{
PushMsg(id, msg, data.Length, im.SenderConnection);
}
} catch (Exception ex) {
LogSystem.Error("Decode Message exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
break;
default:
break;
}
m_NetClient.Recycle(im);
}
} catch (Exception e) {
LogSystem.Error("Exception:{0}\n{1}", e.Message, e.StackTrace);
}
}
public void Update()
{
if (_receivedMessages.Count > 0)
{
networkClient.Recycle(_receivedMessages);
_receivedMessages.Clear();
}
if (networkClient.ReadMessages(_receivedMessages) > 0)
{
for (int i = _receivedMessages.Count - 1; i >= 0; i--)
{
if (_receivedMessages[i].MessageType == NetIncomingMessageType.Data && _receivedMessages[i].PeekByte() == (byte)CommandType.UpdatePlayerInfo)
{
if (_packets > 150)
{
_averagePacketTime = 0f;
_packets = 0;
}
if (Time.realtimeSinceStartup - _lastPacketTime < 0.2f)
{
_averagePacketTime += Time.realtimeSinceStartup - _lastPacketTime;
_packets++;
if (_averagePacketTime != 0f && _packets != 0)
{
tickrate = 1f / (_averagePacketTime / _packets);
}
}
else
{
_averagePacketTime = 0f;
_packets = 0;
}
_lastPacketTime = Time.realtimeSinceStartup;
MessageReceived?.Invoke(_receivedMessages[i]);
_receivedMessages[i].Position = 0;
break;
}
}
if (Config.Instance.SpectatorMode)
{
for (int i = 0; i < _receivedMessages.Count; i++)
{
_receivedMessages[i].Position = 0;
if (_receivedMessages[i].MessageType == NetIncomingMessageType.Data && _receivedMessages[i].PeekByte() == (byte)CommandType.GetPlayerUpdates)
{
PlayerInfoUpdateReceived?.Invoke(_receivedMessages[i]);
_receivedMessages[i].Position = 0;
}
}
}
foreach (NetIncomingMessage msg in _receivedMessages)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
{
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected && !connected)
{
connected = true;
ConnectedToServerHub?.Invoke();
}
else if (status == NetConnectionStatus.Disconnected && connected)
{
Plugin.log.Debug("Disconnecting...");
Disconnect();
MessageReceived?.Invoke(null);
}
else if (status == NetConnectionStatus.Disconnected && !connected)
{
Plugin.log.Error("ServerHub refused connection! Reason: " + msg.ReadString());
}
}
break;
case NetIncomingMessageType.Data:
{
CommandType commandType = (CommandType)msg.PeekByte();
switch (commandType)
{
case CommandType.Disconnect:
{
Plugin.log.Debug("Disconnecting...");
Disconnect();
MessageReceived?.Invoke(msg);
}
break;
case CommandType.SendEventMessage:
{
string header = msg.ReadString();
string data = msg.ReadString();
Plugin.log.Debug($"Received event message! Header=\"{header}\", Data=\"{data}\"");
foreach (Action <string, string> nextDel in EventMessageReceived.GetInvocationList())
{
try
{
nextDel?.Invoke(header, data);
}
catch (Exception e)
{
if (nextDel != null)
{
Plugin.log.Error($"Exception in {nextDel.Target.GetType()}.{nextDel.Method.Name} on event message received event: {e}");
}
else
{
Plugin.log.Error($"Exception in {nextDel.Target.GetType()}.{nextDel.Method.Name} on event message received event: {e}");
}
}
}
}
break;
case CommandType.JoinRoom:
{
msg.Position = 8;
if (msg.PeekByte() == 0 && ClientJoinedRoom != null)
{
foreach (Action nextDel in ClientJoinedRoom.GetInvocationList())
{
try
{
nextDel?.Invoke();
}
catch (Exception e)
{
if (nextDel != null)
{
Plugin.log.Error($"Exception in {nextDel.Target.GetType()}.{nextDel.Method.Name} on client joined room event: {e}");
}
else
{
Plugin.log.Error($"Exception on client joined room event: {e}");
}
}
}
}
MessageReceived?.Invoke(msg);
}
break;
case CommandType.StartLevel:
{
#if DEBUG
startNewDump = true;
packetsBuffer.Clear();
msg.Position = 8;
LevelOptionsInfo levelInfo = new LevelOptionsInfo(msg);
SongInfo songInfo = new SongInfo(msg);
List <byte> buffer = new List <byte>();
buffer.AddRange(levelInfo.ToBytes());
buffer.AddRange(HexConverter.ConvertHexToBytesX(songInfo.hash));
Plugin.log.Info("LevelID: " + songInfo.levelId + ", Bytes: " + BitConverter.ToString(buffer.ToArray()));
packetsBuffer.Enqueue(buffer.ToArray());
msg.Position = 0;
#endif
if (playerInfo != null && playerInfo.updateInfo.playerState == PlayerState.Room && ClientLevelStarted != null)
{
foreach (Action nextDel in ClientLevelStarted.GetInvocationList())
{
try
{
nextDel?.Invoke();
}
catch (Exception e)
{
if (nextDel != null)
{
Plugin.log.Error($"Exception in {nextDel.Target.GetType()}.{nextDel.Method.Name} on client level started event: {e}");
}
else
{
Plugin.log.Error($"Exception on client level started event: {e}");
}
}
}
}
MessageReceived?.Invoke(msg);
}
break;
case CommandType.UpdatePlayerInfo:
break;
default:
{
MessageReceived?.Invoke(msg);
}
break;
}
};
break;
case NetIncomingMessageType.WarningMessage:
Plugin.log.Warn(msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Plugin.log.Error(msg.ReadString());
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
Plugin.log.Debug(msg.ReadString());
break;
default:
Plugin.log.Debug("Unhandled message type: " + msg.MessageType);
break;
}
}
networkClient.Recycle(_receivedMessages);
_receivedMessages.Clear();
}
if (connected && networkClient.ConnectionsCount == 0)
{
Plugin.log.Debug("Connection lost! Disconnecting...");
Disconnect();
MessageReceived?.Invoke(null);
}
/*
* if((Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl)) && Input.GetKeyDown(KeyCode.F1))
* {
* GarbageCollector.GCMode = GarbageCollector.GCMode == GarbageCollector.Mode.Enabled ? GarbageCollector.Mode.Disabled : GarbageCollector.Mode.Enabled;
* Plugin.log.Notice($"Garbage collector {GarbageCollector.GCMode.ToString()}!");
* }
*/
}
public void ServerHandleMessage(object sender, System.Timers.ElapsedEventArgs e)
{
try
{
#region HandleMessage
ServerMain.TimerPackage.Stop();
NetIncomingMessage im;
string message = string.Empty;
Byte[] Bymessage;
//ServerHandler handler;
if ((im = server.ReadMessage()) == null)
{
return;
}
//Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + "ServerHandleMessage");
client = im.SenderConnection;
// handle incoming message
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
message = im.ReadString();
Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + message);
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + status.ToString());
if (status == NetConnectionStatus.Connected)
{
Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + NetUtility.ToHexString(im.SenderConnection.RemoteUniqueIdentifier));
//Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + "Remote hail: " + im.SenderConnection.RemoteHailMessage.ReadString() + " from " + im.SenderEndPoint.ToString());
client = im.SenderConnection;
Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + im.SenderConnection.ToString());
Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + "Ping = " + client.AverageRoundtripTime.ToString() + " S");
}
if (status == NetConnectionStatus.Disconnected)
{
uint id = 0;
foreach (uint uid in ServerMain.allUser.Keys)
{
if (ServerMain.allUser[uid].connection == client)
{
id = uid;
}
}
if (id != 0)
{
clsChangeUser changeUser = new clsChangeUser(id, ServerMain.allUser[id].name);
Package packageUser = new Package((uint)Protocol.KILLUSER, changeUser.ToBytes());
ServerMain.toAllClient.Enqueue(packageUser);
ServerMain.allConnections.Remove(ServerMain.allUser[id].connection);
ServerMain.allUser.Remove(id);
}
}
Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + "Peer:" + im.SenderConnection.Peer.ToString());
break;
case NetIncomingMessageType.Data:
Bymessage = im.ReadBytes(4);
Package package = new Package(BitConverter.ToUInt32(Bymessage, 0));
//Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + "[C-->S] " + (Protocol)package.protocol + "\n");
int _length = BitConverter.ToInt32(im.ReadBytes(4), 0);
List <byte> _data = new List <byte>();
for (int i = 0; i < _length; i++)
{
_data.AddRange(im.ReadBytes(1));
}
package.data = _data.ToArray();
package.user = client;
switch (package.protocol)
{
case (uint)Protocol.LOGIN:
inLogin(package);
break;
case (uint)Protocol.SEND:
inSend(package);
break;
case (uint)Protocol.SECRET:
isSecret(package);
break;
}
break;
default:
Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + "Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes " + im.DeliveryMethod + "|" + im.SequenceChannel);
break;
}
server.Recycle(im);
#endregion
}
catch (Exception er)
{
Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + er.ToString());
}
finally
{
ServerMain.TimerPackage.Start();
}
}
private void UpdateConnectionsDictionary(NetConnectionStatus status)
{
if (status == NetConnectionStatus.Connected)
{
var senderId = messageIn.SenderConnection.RemoteUniqueIdentifier;
if (connections.ContainsKey(senderId))
{
connections.Remove(senderId);
}
connections.Add(senderId, messageIn.SenderConnection);
// Store the event as a message
var message = new Message
{
ClientId = messageIn.SenderConnection.RemoteUniqueIdentifier,
Type = MessageType.Connect,
RemoteTimeOffset = messageIn.SenderConnection.RemoteTimeOffset
};
Messages.Add(message);
Logger.Log<LidgrenServer>(LogLevel.Info, string.Format("Client {0} connected from IP {1}", senderId, messageIn.SenderEndpoint.Address));
}
else if (status == NetConnectionStatus.Disconnected)
{
var senderId = messageIn.SenderConnection.RemoteUniqueIdentifier;
if (connections.ContainsKey(senderId))
{
connections.Remove(senderId);
}
// Store the event as a message
var message = new Message
{
ClientId = messageIn.SenderConnection.RemoteUniqueIdentifier,
Type = MessageType.Disconnect
};
Messages.Add(message);
Logger.Log<LidgrenServer>(LogLevel.Info, string.Format("Client {0} disconnected with IP {1}", senderId, messageIn.SenderEndpoint.Address));
}
}
protected virtual void OnStatusChange(NetIncomingMessage message, NetConnectionStatus status)
{
Log.Debug(status + ": " + message.ReadString());
}
/// <summary>
/// When overridden in the derived class, allows for handling when the status of an <see cref="IIPSocket"/> changes.
/// </summary>
/// <param name="sender">The <see cref="IIPSocket"/> who's status has changed.</param>
/// <param name="status">The new status.</param>
/// <param name="reason">The reason for the status change.</param>
protected override void OnReceiveStatusChanged(IIPSocket sender, NetConnectionStatus status, string reason)
{
base.OnReceiveStatusChanged(sender, status, reason);
switch (status)
{
case NetConnectionStatus.Disconnected:
// If there was an account on the socket, destroy it
var acc = World.GetUserAccount(sender, false);
if (acc != null)
acc.Dispose();
break;
case NetConnectionStatus.Connected:
// Send the server time to the client
using (var pw = ServerPacket.SetGameTime(DateTime.Now))
{
sender.Send(pw, ServerMessageType.GUI);
}
break;
}
}
/// <summary>
/// Recebe os dados.
/// </summary>
public static void ReceivedData()
{
NetIncomingMessage msg;
while ((msg = Socket.ReadMessage()) != null)
{
var pData = Authentication.FindByConnection(msg.SenderConnection);
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
Socket.SendDiscoveryResponse(null, msg.SenderEndPoint);
LogConfig.WriteLog($"Discovery Response IPEndPoint: {msg.SenderEndPoint.Address}", Color.Coral);
break;
case NetIncomingMessageType.ErrorMessage:
#region ErrorMessage
var error = msg.ReadString();
LogConfig.WriteLog($"Error: {error}", Color.Coral);
#endregion
break;
case NetIncomingMessageType.StatusChanged:
#region StatusChanged : Connected
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
LogConfig.WriteLog($"Status changed to connected: {msg.SenderEndPoint.Address}", Color.Coral);
Authentication.Player.Add(new PlayerData(msg.SenderConnection, string.Empty, msg.SenderEndPoint.Address.ToString()));
WorldServerPacket.NeedHexID(msg.SenderConnection);
}
#endregion
#region StatusChanged : Disconnected
if (status == NetConnectionStatus.Disconnected)
{
pData = Authentication.FindByConnection(msg.SenderConnection);
LogConfig.WriteLog($"Status changed to disconnected: {pData.AccountID} {pData?.Account} {msg.SenderEndPoint.Address} {pData.HexID}", Color.Coral);
pData.Clear();
Authentication.Player.Remove(pData);
}
#endregion
break;
case NetIncomingMessageType.Data:
WorldServerData.HandleData(pData.Connection, msg);
break;
default:
if (Settings.LogSystem)
{
LogConfig.WriteLog($"Unhandled type: {msg.MessageType}");
}
Program.WorldForm.WriteLog($"Unhandled type: {msg.MessageType}", Color.DarkRed);
break;
}
Socket.Recycle(msg);
}
}
internal void SetStatus(NetConnectionStatus status, string reason)
{
// user or library thread
if (status == m_status)
return;
m_status = status;
if (reason == null)
reason = string.Empty;
if (m_status == NetConnectionStatus.Connected)
{
m_timeoutDeadline = (float)NetTime.Now + m_peerConfiguration.m_connectionTimeout;
m_peer.LogVerbose("Timeout deadline initialized to " + m_timeoutDeadline);
}
if (m_peerConfiguration.IsMessageTypeEnabled(NetIncomingMessageType.StatusChanged))
{
NetIncomingMessage info = m_peer.CreateIncomingMessage(NetIncomingMessageType.StatusChanged, 4 + reason.Length + (reason.Length > 126 ? 2 : 1));
info.m_senderConnection = this;
info.m_senderEndPoint = m_remoteEndPoint;
info.Write((byte)m_status);
info.Write(reason);
m_peer.ReleaseMessage(info);
}
else
{
// app dont want those messages, update visible status immediately
m_visibleStatus = m_status;
}
}
public static void UpdateNetwork()
{
NetIncomingMessage msg;
if (server == null)
{
return;
}
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
Console.WriteLine("{0}: {1}", msg.MessageType, msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
{
if (msg.SenderConnection == null)
{
break;
}
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
string reason = msg.ReadString();
Console.WriteLine("StatusChanged: {0} '{1}'", status, reason);
switch (status)
{
case NetConnectionStatus.Connected:
{
if (State == States.InGame && !AllowLateJoins)
{
// F**k off, no visitors
msg.SenderConnection.Disconnect("Already in game, f**k off.");
break;
}
if (Clients.Count == Constants.MaxPlayerCount)
{
msg.SenderConnection.Disconnect("Too crowded, f**k off.");
break;
}
ServerClient client = new ServerClient(msg.SenderConnection, GenerateId());
msg.SenderConnection.Tag = client;
Clients.Add(client);
if (State == States.Lobby)
{
ServerList.Update();
}
break;
}
case NetConnectionStatus.Disconnected:
{
if (msg.SenderConnection.Tag == null)
{
break;
}
ServerClient serverClient = (ServerClient)msg.SenderConnection.Tag;
if (serverClient.Verified)
{
SendMessageToAllExcept(new PlayerDelete(serverClient.Id), serverClient.Id);
ServerClient client = (ServerClient)msg.SenderConnection.Tag;
client.Disconnect();
Clients.Remove(client);
// Card Czar left like the asshole he is
if (serverClient.Id == currentCardCzar)
{
DeclareWinner(Clients[Random.Next(Clients.Count)].Id);
}
if (State == States.Lobby)
{
ServerList.Update();
}
}
else
{
Clients.Remove((ServerClient)msg.SenderConnection.Tag);
}
break;
}
}
break;
}
case NetIncomingMessageType.Data:
{
if (msg.SenderConnection == null || msg.SenderConnection.Tag == null)
{
break;
}
ServerClient client = (ServerClient)msg.SenderConnection.Tag;
Packet packet = Packet.ReadFromMessage(msg);
client.HandleMessage(packet);
break;
}
default:
Console.WriteLine("Unhandled type: " + msg.MessageType);
break;
}
server.Recycle(msg);
}
HandleGame();
}
