private void Run()
{
try
{
TcpListener server = new TcpListener(IPAddress.Any, port);
server.Start();
ServerStarted?.Invoke();
while (!stop)
{
if (server.Pending())
{
Socket connection = server.AcceptSocket();
Worker w = new Worker(this, connection, "Client " + idCounter++);
lock (workersLock)
{
workers.Add(w);
UserConnected?.Invoke(w.Username);
}
}
}
server.Server.Close(); // Release all resources
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
finally
{
ServerClosed?.Invoke();
}
}
private void ConnectCommand(NetworkMessage message)
{
if (message.TryGetObject <string>(out string connectedUser))
{
UserConnected?.Invoke(connectedUser);
}
}
private void NotifierOnUserConnected(object sender, NotifierEventArgs <User> notifierEventArgs)
{
if (notifierEventArgs?.Payload != null)
{
var user = notifierEventArgs.Payload;
Friends.Add(user);
UserConnected?.Invoke(this, notifierEventArgs);
}
}
public void UpdateServer()
{
NetIncomingMessage inc = null;
while (server != null && (inc = server.ReadMessage()) != null)
{
switch (inc.MessageType)
{
case NetIncomingMessageType.StatusChanged:
Console.WriteLine(inc.SenderEndPoint.ToString() + " Status: " + inc.SenderConnection.Status.ToString());
switch (inc.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
if ((connections.Count >= maxConnections && maxConnections > 0) || AcceptIncomingConnections == false)
{
inc.SenderConnection.Disconnect("Server full");
}
else
{
connections.Add(inc.SenderConnection);
UserConnected?.Invoke(this, new ProviderUserEventArgs()
{
UserKey = inc.SenderConnection,
});
}
break;
case NetConnectionStatus.Disconnected:
connections.Remove(inc.SenderConnection);
UserDisconnected?.Invoke(this, new ProviderUserEventArgs()
{
UserKey = inc.SenderConnection,
});
break;
}
break;
case NetIncomingMessageType.Data:
var bytes = inc.ReadBytes(inc.LengthBytes);
DataReceived?.Invoke(this, new ProviderDataEventArgs(inc.SenderConnection, true, new DataBuffer(bytes), inc.LengthBytes));
break;
case NetIncomingMessageType.Error:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
Console.WriteLine(DateTime.Now.ToShortTimeString() + "Lidgren Server" + inc.ReadString());
break;
}
}
}
/// <summary>
/// Trace the event that a client connected.
/// </summary>
/// <param name="remoteAddress">The client that connected.</param>
internal void TraceUserConnection(IPEndPoint remoteAddress)
{
Task.Run(() =>
{
lock (ConnectedUsersSyncRoot)
connectedUsers.Add(remoteAddress);
try
{
UserConnected?.Invoke(remoteAddress);
}
catch { }
});
}
private void StartAccept()
{
isAccepting = true;
acceptThread = new Thread(() =>
{
while (isAccepting)
{
var user = new GameUser(string.Empty, main.Accept());
pool.Add(user);
UserConnected?.Invoke(this, new GameEventArgs(user, string.Empty));
}
});
acceptThread.IsBackground = true;
acceptThread.Start();
}
private void OnConnect(IAsyncResult ar)
{
var conn = ar.AsyncState as Socket;
conn.EndConnect(ar);
if (conn.Connected)
{
UserConnected?.Invoke(this, new ProviderUserEventArgs()
{
UserKey = conn
});
StateObject state = new StateObject();
state.socket = conn;
conn.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, OnReceive, state);
}
}
public void TryConnectClient(DirectClientProvider client)
{
if (AcceptIncomingConnections)
{
Clients.Add(client);
UserConnected?.Invoke(this, new ProviderUserEventArgs()
{
UserKey = client,
});
client.AcceptConnection(this);
}
else
{
client.RejectConnection(this);
}
}
private void OnClientConnect(IAsyncResult asyncResult)
{
try
{
Socket socket = this.serverSocket.EndAccept(asyncResult);
var conn = new TcpConnection(socket);
conn.Disconnected += this.OnClientDisconnected;
conn.StartListen();
connections.TryAdd(conn.Id, conn);
UserConnected?.Invoke(conn);
serverSocket.BeginAccept(this.OnClientConnect, null);
}
catch (ObjectDisposedException)
{
// This exception was preventing the console from closing when the
// shutdown command was issued.
}
}
public virtual void Add(IOnlineClient client)
{
lock (SyncObj)
{
var userWasAlreadyOnline = false;
var context = client.ToClientContextOrNull();
if (context != null)
{
userWasAlreadyOnline = this.IsOnline(context);
}
Store.Add(client);
ClientConnected?.Invoke(this, new OnlineClientEventArgs(client));
if (context != null && !userWasAlreadyOnline)
{
UserConnected?.Invoke(this, new OnlineUserEventArgs(context, client));
}
}
}
public void Connect(INetContext context)
{
if (IsConnected)
{
Disconnect();
}
message = new byte[1024 * 512];
client = new TcpClient {
NoDelay = false
};
client.SendBufferSize = client.ReceiveBufferSize = 1024 * 256;
client.Connect(context.IPAddress, context.Port);
if (client.Connected)
{
UserConnected?.Invoke(this, new ProviderUserEventArgs());
IsConnected = true;
}
}
public void Init()
{
if (_isInitialized)
{
return;
}
_isInitialized = true;
_hubConnection = new HubConnection(Secrets.GoHubUrl);
_goHub = _hubConnection.CreateHubProxy("GoHub");
_goHub.On(nameof(UserConnected), (UserPrefs user) => UserConnected?.Invoke(user));
_goHub.On(nameof(UserDisconnected), (string user) => UserDisconnected?.Invoke(user));
_goHub.On(nameof(LobbyPost), (Post post) => LobbyPost?.Invoke(post));
_goHub.On(nameof(GamePost), (Post post) => GamePost?.Invoke(post));
_goHub.On(nameof(GameRequested), (string name) => GameRequested?.Invoke(name));
_goHub.On(nameof(GameRequestDeclined), (string name) => GameRequestDeclined?.Invoke(name));
_goHub.On(nameof(GameRequestCancelled), (string name) => GameRequestCancelled?.Invoke(name));
_goHub.On(nameof(GameRequestAccepted), (string name) => GameRequestAccepted?.Invoke(name));
_goHub.On(nameof(GameAborted), (string name) => GameAborted?.Invoke(name));
}
public void UpdateClient()
{
NetIncomingMessage inc = null;
while (client != null && (inc = client.ReadMessage()) != null)
{
switch (inc.MessageType)
{
case NetIncomingMessageType.StatusChanged:
switch (inc.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
UserConnected?.Invoke(this, new ProviderUserEventArgs());
break;
case NetConnectionStatus.Disconnected:
UserDisconnected?.Invoke(this, new ProviderUserEventArgs());
break;
}
break;
case NetIncomingMessageType.Data:
var bytes = inc.ReadBytes(inc.LengthBytes);
DataReceived?.Invoke(this, new ProviderDataEventArgs(null, true, new DataBuffer(bytes), inc.LengthBytes));
break;
case NetIncomingMessageType.Error:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
Console.WriteLine(DateTime.Now.ToShortTimeString() + "Lidgren Client" + inc.ReadString());
break;
}
}
}
protected virtual void OnUserConnected(ulong userId, uint roomId)
{
UserConnected?.Invoke(userId, roomId);
}
public void OnUserConnected(object sender, NotifierEventArgs <User> eventArgs)
{
UserConnected?.Invoke(sender, eventArgs);
}
public void UpdateServer()
{
if (IsActive == false)
{
return;
}
//If any clients are waiting to connect
if (clientListener != null && clientListener.Pending())
{
TcpClient newClient = clientListener.AcceptTcpClient();
newClient.SendBufferSize = newClient.ReceiveBufferSize = 1024 * 256;
newClient.NoDelay = false;
if (AcceptIncomingConnections)
{
connected.Add(newClient);
clientList.Add(newClient);
//Delegate
UserConnected?.Invoke(this, new ProviderUserEventArgs()
{
UserKey = newClient,
});
}
}
if (clientList == null)
{
return;
}
//Update each client, listening for any incoming data.
for (int i = clientList.Count - 1; i >= 0; i--)
{
TcpClient tcpClient = clientList[i];
//If the client is no longer connected, fire off a disconnection event delegate
if (!tcpClient.Connected)
{
DisconnectUser(tcpClient);
continue;
}
//Attempt to read any incoming data from this client
int bytesRead = 0;
int totalBytesRead = 0;
NetworkStream messageStream = tcpClient.GetStream();
MemoryStream memStream = new MemoryStream();
if (messageStream.DataAvailable)
{
var buff = new DataBuffer();
while (messageStream.DataAvailable)
{
bytesRead = messageStream.Read(message, 0, message.Length);
byte[] data = new byte[bytesRead];
Array.Copy(message, data, bytesRead);
buff.Write((byte[])data, 0, data.Length);
totalBytesRead += bytesRead;
}
buff.Seek(0);
while (buff.GetPosition() < buff.GetLength())
{
var size = buff.ReadInt16();
if (size == 0)
{
break;
}
byte[] d = new byte[size];
buff.ReadBytes(d, 0, d.Length);
d = Decompress(d);
if (d.Length == 1 && d[0] == 0)
{
DisconnectUser(tcpClient);
break;
}
DataBuffer msgBuffer = new DataBuffer(d);
msgBuffer.Seek(0);
//Delegate that other classes can attach to, mainly the network handler
DataReceived?.Invoke(this, new ProviderDataEventArgs(tcpClient, true, msgBuffer, msgBuffer.GetLength()));
}
}
}
}
void UserConnectedHandler(string _userName)
{
UserConnected?.Invoke(this, _userName);
}
private static void Client_ClientConnected(Client sender)
{
connectedClients.Add(sender);
UserConnected?.Invoke(sender);
}
private static void Responses()
{
while (ResponseThreadRunning)
{
// listens to responses from the middle man server
string response = GetResponse();
if (response != "")
{
string[] sections = response.Split('|');
string responseType = sections[0];
string parameters = sections[1].Replace("\r", "").Replace("\n", "");
Console.WriteLine(responseType + " | " + parameters);
switch (responseType)
{
case "CONNECTED":
User.Name = parameters;
ConnectedSuccess?.Invoke();
break;
case "PING":
SendMessage("PONG|");
break;
case "LOBBY_LIST":
string[] lobbies = parameters.Split(',');
List <LobbyListItem> lobbyList = new List <LobbyListItem>();
foreach (string lobby in lobbies)
{
string[] info = lobby.Split('-');
if (int.TryParse(info[0], out int id) && int.TryParse(info[2], out int status) && int.TryParse(info[3], out int player_count))
{
lobbyList.Add(new LobbyListItem(id, info[1], (LobbyStatus)status, player_count));
}
}
NewLobbyList?.Invoke(lobbyList);
break;
case "HOSTING":
LobbyCreated?.Invoke();
break;
case "PUNCH-HOST":
Console.WriteLine("HOST PUNCHING");
Socket connectionToC = PerformPunchThrough(sections[1].Split(':'));
if (connectionToC != null)
{
SendMessage("PLAYER_CONNECT_SUCCESS|");
UserConnected?.Invoke(connectionToC);
}
else
{
SendMessage("PLAYER_CONNECT_FAIL|");
}
break;
case "PUNCH-CLIENT":
Console.WriteLine("CLIENT PUNCHING");
Socket connectionToH = PerformPunchThrough(sections[1].Split(':'));
if (connectionToH != null)
{
JoinLobbySuccess?.Invoke(connectionToH);
}
else
{
JoinLobbyFailure.Invoke();
}
break;
}
}
else
{
// AttemptReconnect();
break;
}
}
}
public void NotifyUserConnected()
{
UserConnected?.Invoke(this, EventArgs.Empty);
}
protected virtual void OnUserConnected(User user, Channel channel, Server server)
{
UserConnected?.Invoke(this, new UserConnectedEvent(user, channel, server, _client));
}
/// <summary>
/// Read and prosess data from stream
/// </summary>
private void ClientStreamReadData()
{
try
{
using (Stream stream = _server.GetStream())
{
BinaryReader streamReader = new BinaryReader(stream);
while (true)
{
PacketType packetType = (PacketType)streamReader.ReadInt32();
switch (packetType)
{
case PacketType.Negotiation:
NegotiationPacket negotiationPacket = new NegotiationPacket(stream);
negotiationPacket.Receive();
Login = negotiationPacket.Login;
_loginEvents[0].Set();
_registerEvents[0].Set();
lock (_rooms)
{
Room mainRoom = new Room(Room.MainRoomId, Room.MainRoomName, new HashSet <string>());
_rooms.Add(Room.MainRoomId, mainRoom);
}
_context.Post(p => NegotiationCompleted?.Invoke(this, EventArgs.Empty), null);
break;
case PacketType.SimpleMessage:
SimpleMessagePacket simpleMessagePacket = new SimpleMessagePacket(stream);
simpleMessagePacket.Receive();
OnSimpleMessageReceived(simpleMessagePacket);
break;
case PacketType.Error:
ErrorPacket errorPacket = new ErrorPacket(stream);
errorPacket.Receive();
_context.Post(p => ErrorOccurred?.Invoke(this, new ErrorOccurredEventHandlerArgs(errorPacket.ErrorMessage, errorPacket.ErrorType)), null);
break;
case PacketType.UserConnect:
UserConnectPacket userConnectPacket = new UserConnectPacket(stream);
userConnectPacket.Receive();
lock (_users)
{
_users[userConnectPacket.UserLogin] = userConnectPacket.UserInfo;
}
_context.Post(p => UserConnected?.Invoke(this, new UserConnectedEventHandlerArgs(userConnectPacket.UserLogin, userConnectPacket.UserInfo)), null);
break;
case PacketType.UserDisconnect:
UserDisconnectPacket userDisconnectPacket = new UserDisconnectPacket(stream);
userDisconnectPacket.Receive();
lock (_users)
{
_users.Remove(userDisconnectPacket.UserLogin);
}
_context.Post(p => UserDisconnected?.Invoke(this, new UserDisconnectedEventHandlerArgs(userDisconnectPacket.UserLogin)), null);
break;
case PacketType.CreateNewRoom:
CreateNewRoomPacket createNewRoomPacket = new CreateNewRoomPacket(stream);
createNewRoomPacket.Receive();
lock (_rooms)
{
_rooms.Add(createNewRoomPacket.Room.Id, createNewRoomPacket.Room);
}
_context.Post(p => NewRoomCreated?.Invoke(this, new NewRoomCreatedEventHandlerArgs(createNewRoomPacket.Room)), null);
break;
case PacketType.AddUserToRoom:
AddUsersToRoomPacket addUsersToRoomPacket = new AddUsersToRoomPacket(stream);
addUsersToRoomPacket.Receive();
lock (_rooms)
{
foreach (string user in addUsersToRoomPacket.Users)
{
_rooms[addUsersToRoomPacket.RoomId].Members.Add(user);
}
}
_context.Post(p => RoomsUpdated?.Invoke(this, new RoomsUpdatedEventHandlerArgs()), null);
break;
case PacketType.RemoveUserFromRoom:
RemoveUserFromRoomPacket removeUserFromRoomPacket = new RemoveUserFromRoomPacket(stream);
removeUserFromRoomPacket.Receive();
lock (_rooms)
{
Room room;
if (_rooms.TryGetValue(removeUserFromRoomPacket.RoomId, out room))
{
room.Members.Remove(removeUserFromRoomPacket.User);
}
}
_context.Post(p => RoomsUpdated?.Invoke(this, new RoomsUpdatedEventHandlerArgs()), null);
break;
}
}
}
}
catch (Exception)
{
_server.Close();
_server.Client.Dispose();
}
}
public void AcceptConnection(DirectServerProvider Server)
{
IsConnected = true;
ActiveServer = Server;
UserConnected?.Invoke(this, new ProviderUserEventArgs());
}
