private async Task UpdateConnection(LobbyConnection lc)
{
lc.PendingUpdates++;
await Messenger.SendMessage(lc.Connection, Messages.GameSettings(lc.Lobby));
await SetConnectionReady(lc, false);
}
private void AssertHost(LobbyConnection lc)
{
if (lc.Lobby.Host != lc)
{
throw new ArgumentException("Connection is not lobby host!");
}
}
public async Task <Lobby> CreateLobby(GameWrapper game, LobbyConnection host, string name)
{
using (var alock = await Data.Synchronizer.SetStateAsync(ModuleState.Writing))
{
log.Debug("creating new lobby '" + name + "' for host " + host);
var lobby = new Lobby(name)
{
Host = host,
Backend = new LobbyBackendWrapper(game)
};
await SetGameMode(lobby, lobby.Backend.DefaultGameMode);
Data.AddLobby(lobby);
try
{
await Broadcast(Messages.LobbyCreated(lobby));
await JoinLobby(host, lobby);
}
catch
{
Data.RemoveLobby(lobby);
throw;
}
return(lobby);
}
}
/// <summary>
/// Processes the message
/// </summary>
/// <param name="connectionBase">The connection base</param>
/// <param name="message">The playerio message</param>
/// <param name="handled">Whether the message was already handled</param>
public void Process(ConnectionBase connectionBase, Message message, bool handled)
{
string title = message.GetString(0);
string text = message.GetString(1);
ChatMessage systemMessage = new ChatMessage(null, string.Format("{0} {1}", title, text));
if (connectionBase is LobbyConnection)
{
LobbyConnection lobbyCon = (LobbyConnection)connectionBase;
if (!handled)
{
lobbyCon.MessageOfTheDay = message.GetString(1);
}
}
else if (connectionBase is WorldConnection)
{
if (!handled)
{
WorldConnection worldCon = (WorldConnection)connectionBase;
worldCon.Chat.Add(systemMessage);
}
}
InfoEvent infoEvent = new InfoEvent()
{
Raw = message,
SystemMessage = systemMessage
};
connectionBase.RaiseServerEvent <InfoEvent>(infoEvent);
}
public async Task SetConnectionReady(LobbyConnection connection, bool v)
{
if (connection.Lobby == null)
{
throw new ArgumentNullException();
}
Data.SetReady(connection, v);
await LobbyBroadcast(connection.Lobby, Messages.ReadyChanged(connection));
}
public async Task AddConnection(LobbyConnectionInitializer initializer)
{
LobbyConnection connection = _connections.AddConnection(initializer.ConnectionId, initializer);
await _context.Groups.AddToGroupAsync(initializer.ConnectionId, connection.LobbyId);
await _context.Clients.Group(connection.LobbyId).UpdateUser(connection.ToLobbyUser());
await _context.Clients.Client(initializer.ConnectionId).UpdateConnectionStatus(connection.ToConnectionStatus());
}
internal Task ConfirmPendingUpdate(LobbyConnection lc)
{
if (Data.Connections[lc.Connection.Id].PendingUpdates == 0)
{
throw new ArgumentException();
}
Data.Connections[lc.Connection.Id].PendingUpdates--;
return(Task.CompletedTask);
}
public async Task JoinLobby(LobbyConnection c, Lobby l)
{
log.Debug("connection " + c + " joining lobby " + l);
using (var alock = await Data.Synchronizer.SetStateAsync(ModuleState.Writing))
{
if (c.Lobby != null)
{
throw new ArgumentException("Connection has already joined a lobby!");
}
if (l.LobbyState == LobbyState.Finished)
{
throw new LobbyStateException("Can not join finished game!");
}
Data.AddLobbyConnection(l, c);
try
{
var players = PlayerStorage.GetPlayerOfConnection(c.Connection);
await AddPlayerToLobby(players, l);
await Messenger.SendMessage(c.Connection, Messages.LobbyJoined(l));
await Messenger.SendMessage(c.Connection, Messages.GameModeChanged(l));
await Messenger.SendMessage(c.Connection, Messages.ReadyStates(l));
//await Messenger.SendMessage(c.Connection, Messages.LobbySettings(l));
await UpdateConnection(c);
}
catch (Exception ex)
{
log.Warn("connection " + c + " failed to join lobby " + l + ", reverting changes");
l.Connections.Remove(c.Connection.Id);
c.Lobby = null;
throw ex;
}
}
}
static void Main(string[] args)
{
//all socket we need
Socket lobby = new Socket(SocketType.Stream, ProtocolType.IP); //for the lobby
lobbyClients = new List <LobbyConnection>();
partecipanti = new List <string>();
//for the player
Socket player1 = new Socket(SocketType.Stream, ProtocolType.IP);
Socket player2 = new Socket(SocketType.Stream, ProtocolType.IP);
Socket player3 = new Socket(SocketType.Stream, ProtocolType.IP);
Socket player4 = new Socket(SocketType.Stream, ProtocolType.IP);
//your mother CANCELLAMI
//metto la socket lobby in ascolto su 2021
try
{
lobby.Bind(new IPEndPoint(IPAddress.Any, WELL_KNOWN_PORT));
lobby.Listen(4);
// Start listening for connections.
while (true)
{
Console.WriteLine("Waiting for a connection...");
// Accetta una nuova connessione
Socket clnt_sck = lobby.Accept();
// Crea un nuovo thread per gestire la connessione
LobbyConnection cc = new LobbyConnection(clnt_sck);
lobbyClients.Add(cc);
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public async Task LeaveLobby(LobbyConnection connection, bool silent)
{
log.Debug("removing connection " + connection + " from lobby " + connection.Lobby);
using (var alock = await Data.Synchronizer.SetStateAsync(ModuleState.Writing))
{
var lobby = connection.Lobby;
if (lobby == null)
{
throw new LobbyStateException("Connection is not member in any lobby!");
}
log.Debug("connection " + connection.Connection.Id + " leaving lobby " + lobby.Id);
if (PlayerStorage.IsSynchronized(connection.Connection))
{
var players = PlayerStorage.GetPlayerOfConnection(connection.Connection).Where(p => lobby.Players.Contains(p)).ToArray();
await RemovePlayerFromLobby(players, lobby, silent);
}
lobby.Connections.Remove(connection.Connection.Id);
if (!silent && connection.Connection.State != ConnectionState.Disconnected)
{
await Messenger.SendMessage(connection.Connection, Messages.LobbyLeft());
}
connection.Lobby = null;
connection.PendingUpdates = 0;
if (lobby.Host == connection)
{
await MigrateHost(lobby);
}
}
}
public Task LeaveLobby(LobbyConnection connection)
{
return(LeaveLobby(connection, false));
}
public ConnectionEstablishedState(LobbyConnection connection)
{
_connection = connection;
}
internal Message ReadyChanged(LobbyConnection lc)
{
return(Messages.CreateMessage("SetReady", lc));
}
/// <summary>
/// Creates a new friend
/// </summary>
/// <param name="lobbyConnection">The lobby connection</param>
/// <param name="username">The username</param>
public Friend(LobbyConnection lobbyConnection, string username)
{
this.m_LobbyConnection = lobbyConnection;
Username = username;
}
private void NetworkStateMachine()
{
const int gameConnectionCount = 2;
switch (_networkState)
{
case NetworkState.Lobby:
_packetCycle = 0;
_noPackCycle = 0;
_requireSoftStop = false;
Interlocked.Exchange(ref _softStopCycle, 0);
var l_conn = ConnectionPicker.GetConnections(GameProcess);
if (!l_conn.Any())
{
_networkState = NetworkState.Unconnected;
LobbyConnection.Clear();
Log.Information($"Network State: NoConnection");
break;
}
LobbyConnection = ExtractConnections(l_conn, null);
OnLobbyUpdate?.Invoke();
var l_game = ExtractConnections(l_conn, LobbyConnection);
if (l_game.Count == gameConnectionCount)
{
GameConnection = l_game;
_networkState = NetworkState.GameUninitialized;
Log.Information($"Network State: GameConnDetected");
}
break;
case NetworkState.Unconnected:
_networkState = NetworkState.Fail;
if (!NetworkInterface.GetIsNetworkAvailable())
{
break;
}
if (!PingHost(ConnectionPicker.GetLobbyEndPoint(GameProcess)))
{
break;
}
_networkState = NetworkState.Pending;
Log.Information($"Network State: WaitingLogin");
break;
case NetworkState.Fail:
Log.Information($"Network State: FailNetworkCheck");
IpcClient.SendSignal(Signal.ClientNetworkFail, new[] { GameProcess.Id.ToString() });
Stopping = true;
break;
case NetworkState.Pending:
if (ConnectionPicker.GetConnections(GameProcess).Any())
{
_networkState = NetworkState.Lobby;
Log.Information($"Network State: ConnectedToLobby");
}
break;
case NetworkState.GameUninitialized:
OnWorldStart?.Invoke();
_networkState = NetworkState.GameInitialized;
Log.Information($"Network State: InitializeInvoked");
break;
case NetworkState.GameInitialized:
if (_requireSoftStop)
{
Interlocked.Increment(ref _softStopCycle);
_networkState = NetworkState.GameNoPacket;
Log.Information($"Network State: ConnectivityCheck");
break;
}
if (GetPacketAmount != null && _previousGamePacketCount != GetPacketAmount?.Invoke())
{
_noPackCycle = 0;
_previousGamePacketCount = GetPacketAmount.Invoke();
break;
}
_packetCycle++;
_noPackCycle++;
if (_packetCycle > 240) // 2min, Quality assurance
{
_networkState = NetworkState.GameNoPacket;
Log.Information($"Network State: ScheduledQA");
}
if (_noPackCycle > 10) // 5s, Suspected disconnected
{
_networkState = NetworkState.GameNoPacket;
Log.Information($"Network State: NoPackNetworkCheck");
}
break;
case NetworkState.GameNoPacket:
var gnp_conn = ConnectionPicker.GetConnections(GameProcess);
if (!_connSetEqCp.Equals(gnp_conn, GameConnection))
{
OnWorldStop?.Invoke();
_networkState = NetworkState.Lobby;
Log.Information($"Network State: ConnectionLost");
break;
}
if (_softStopCycle > 20) // 10s, Kept monitoring
{
_requireSoftStop = false;
Interlocked.Exchange(ref _softStopCycle, 0);
}
_packetCycle = 0;
_noPackCycle = 0;
_networkState = NetworkState.GameInitialized;
Log.Information($"Network State: Normal");
break;
default:
_networkState = NetworkState.Lobby;
Log.Information($"Network State: UnrecognizedToLobby");
break;
}
}
public InQueueState(LobbyConnection connection, string accountId)
{
_connection = connection;
_accountId = accountId;
}
public AuthenticatingState(LobbyConnection connection, string accountId)
{
_connection = connection;
_accountId = accountId;
}
