// Construction
public CBrowseLobbyAddRemoveMessage( CLobbySummary new_lobby, ELobbyID removed_lobby )
: base()
{
Lobbies = new List< CLobbySummary >();
if ( new_lobby != null )
{
Lobbies.Add( new_lobby );
}
RemovedLobby = removed_lobby;
}
// Public interface
// Operations
// Channel Creation
public static void Create_Lobby_Chat_Channel( CChatChannelConfig channel_config, ELobbyID lobby_id, EPersistenceID source_player )
{
CCreateChatChannelRequestServerMessage create_lobby_channel_message = new CCreateChatChannelRequestServerMessage( channel_config );
create_lobby_channel_message.Handler =
delegate( CResponseMessage response )
{
CCreateChatChannelResponseServerMessage response_msg = response as CCreateChatChannelResponseServerMessage;
On_Lobby_Chat_Channel_Creation_Response( lobby_id, source_player, response_msg );
};
CServerMessageRouter.Send_Message_To_Chat_Server( create_lobby_channel_message );
}
public static string Get_Lobby_Log_Description( ELobbyID lobby_id )
{
CLobby lobby = Instance.Get_Lobby( lobby_id );
if ( lobby != null )
{
return lobby.GameDescription;
}
else
{
return String.Format( "Lobby#{0}", (int)lobby_id );
}
}
public void Insert_Watched_Lobby( ELobbyID lobby_id )
{
if ( m_WatchedLobbies.Count == 0 )
{
m_WatchedLobbies.Add( lobby_id );
return;
}
// dumb and linear
int index = 0;
while ( index < m_WatchedLobbies.Count && lobby_id > m_WatchedLobbies[ index ] )
{
index++;
}
m_WatchedLobbies.Insert( index, lobby_id );
}
private static void On_Lobby_Chat_Channel_Join_Response( EPersistenceID player_id, ELobbyID lobby_id, CJoinChatChannelResponseServerMessage response )
{
CServerLobbyManager.Instance.On_Lobby_Chat_Channel_Join_Response( lobby_id, player_id, response );
}
public static void Player_Join_Lobby_Channel( EPersistenceID player_id, ELobbyID lobby_id, EChannelID channel_id )
{
Change_System_Channel( player_id,
channel_id,
EChannelGameProperties.OrdinarySingletonMask,
delegate( CResponseMessage response ) {
On_Lobby_Chat_Channel_Join_Response( player_id, lobby_id, response as CJoinChatChannelResponseServerMessage );
} );
}
private void Send_Message_To_Members( ELobbyID lobby_id, CNetworkMessage message )
{
Send_Message_To_Members( lobby_id, message, EPersistenceID.Invalid );
}
private void On_Join_Lobby_Failure( ELobbyID lobby_id, EPersistenceID player_id, EMessageRequestID request_id, EJoinLobbyFailureReason reason )
{
CLog.Log( ELoggingChannel.Lobby, ELogLevel.Medium, String.Format( "Player {0} failed to join lobby {1} because of {2}.",
CConnectedPlayerManager.Get_Player_Log_Name( player_id ),
Get_Lobby_Log_Description( lobby_id ),
reason.ToString() ) );
CConnectedPlayer player = CConnectedPlayerManager.Instance.Get_Player_By_Persistence_ID( player_id );
if ( player != null )
{
player.Change_State( EConnectedPlayerState.Chat_Idle );
}
if ( !CConnectedPlayerManager.Instance.Is_Connected( player_id ) )
{
return;
}
CJoinLobbyFailure join_response = new CJoinLobbyFailure( request_id, reason );
CServerMessageRouter.Send_Message_To_Player( join_response, player_id );
}
public void On_Lobby_Chat_Channel_Creation_Response( ELobbyID lobby_id, EPersistenceID player_id, CCreateChatChannelResponseServerMessage response_msg )
{
CServerLobby lobby = Get_Lobby( lobby_id );
if ( lobby == null )
{
if ( response_msg.ChannelID != EChannelID.Invalid )
{
CDestroyChatChannelServerMessage destroy_channel_message = new CDestroyChatChannelServerMessage( response_msg.ChannelID );
CServerMessageRouter.Send_Message_To_Chat_Server( destroy_channel_message );
}
return;
}
CLog.Log( ELoggingChannel.Lobby, ELogLevel.Medium, String.Format( "Lobby {0} chat channel {1} creation result = {2}.",
Get_Lobby_Log_Description( lobby_id ),
response_msg.ChannelName,
response_msg.Error.ToString() ) );
if ( response_msg.Error != EChannelCreationError.None )
{
Shutdown_Lobby( lobby_id, ELobbyDestroyedReason.Chat_Channel_Creation_Failure );
return;
}
lobby.Initialize_Chat_Channel( response_msg.ChannelID );
lobby.ConnectedMemberIDs.Apply( pid => CAsyncBackendOperations.Player_Join_Lobby_Channel( pid, lobby_id, lobby.ChatChannel ) );
}
// Methods
// Public interface
public void Join_Lobby_By_Browsing( EPersistenceID player_id, ELobbyID lobby_id )
{
Join_Lobby_Aux( player_id, Get_Lobby( lobby_id ), EMessageRequestID.Invalid, "" );
}
public CServerLobby Get_Lobby( ELobbyID lobby_id )
{
CServerLobby lobby = null;
if ( !m_Lobbies.TryGetValue( lobby_id, out lobby ) )
{
return null;
}
return lobby;
}
// Methods
// Public interface
public void Initialize( ELobbyID id, uint player_count, uint observer_count )
{
ID = id;
PlayerCount = player_count;
ObserverCount = observer_count;
}
// Methods
// Public interface
public void Initialize( ELobbyID id, CLobbyConfig config, DateTime creation_time, EPersistenceID creator, uint player_count, uint observer_count )
{
Config = config.Clone( false );
ID = id;
CreationTime = creation_time;
Creator = creator;
PlayerCount = player_count;
ObserverCount = observer_count;
}
public void Remove_Watched_Lobby( ELobbyID lobby_id )
{
m_WatchedLobbies.Remove( lobby_id );
}
public bool Is_Watching( ELobbyID lobby_id )
{
return m_WatchedLobbies.Contains( lobby_id );
}
private void On_Create_Lobby_Failure( ELobbyID lobby_id, EPersistenceID player_id, EMessageRequestID request_id, ECreateLobbyFailureReason reason )
{
CLog.Log( ELoggingChannel.Lobby, ELogLevel.Medium, String.Format( "{0}'s lobby {1} failed to create because {2}.",
CConnectedPlayerManager.Get_Player_Log_Name( player_id ),
Get_Lobby_Log_Description( lobby_id ),
reason.ToString() ) );
Shutdown_Lobby( lobby_id, ELobbyDestroyedReason.Creation_Failure );
CConnectedPlayer player = CConnectedPlayerManager.Instance.Get_Player_By_Persistence_ID( player_id );
if ( player != null )
{
player.Change_State( EConnectedPlayerState.Chat_Idle );
}
if ( !CConnectedPlayerManager.Instance.Is_Connected( player_id ) )
{
return;
}
CCreateLobbyFailure create_response = new CCreateLobbyFailure( request_id, reason );
CServerMessageRouter.Send_Message_To_Player( create_response, player_id );
}
private void On_Create_Lobby_Success( EPersistenceID player_id, EMessageRequestID request_id, ELobbyID lobby_id )
{
CServerLobby lobby = Get_Lobby( lobby_id );
CConnectedPlayer player = CConnectedPlayerManager.Instance.Get_Player_By_Persistence_ID( player_id );
player.On_Join_Lobby_Success( lobby_id );
CLog.Log( ELoggingChannel.Lobby, ELogLevel.Medium, String.Format( "Player {0}'s lobby {1} successfully created.",
player.Name,
lobby.GameDescription ) );
CCreateLobbySuccess create_response = new CCreateLobbySuccess( request_id, lobby.Clone_State() );
CServerMessageRouter.Send_Message_To_Player( create_response, player_id );
if ( lobby.IsPublic )
{
CServerLobbyBrowserManager.Instance.Notify_Browsers_Of_New_Lobby( lobby_id );
}
}
public void On_Lobby_Chat_Channel_Join_Response( ELobbyID lobby_id, EPersistenceID player_id, CJoinChatChannelResponseServerMessage response_msg )
{
CLog.Log( ELoggingChannel.Lobby, ELogLevel.Medium, String.Format( "Lobby {0} chat channel join result = {1}.",
Get_Lobby_Log_Description( lobby_id ),
response_msg.Error.ToString() ) );
CServerLobby lobby = Get_Lobby( lobby_id );
if ( lobby == null )
{
return;
}
if ( !lobby.Is_Member( player_id ) )
{
return;
}
if ( response_msg.Error != EChannelJoinError.None )
{
if ( player_id == lobby.Creator )
{
Shutdown_Lobby( lobby_id, ELobbyDestroyedReason.Chat_Channel_Join_Failure );
}
else
{
Remove_From_Lobby( lobby_id, player_id, ERemovedFromLobbyReason.Unable_To_Join_Chat_Channel );
}
}
}
private void On_Join_Lobby_Success( EPersistenceID player_id, EMessageRequestID request_id, ELobbyID lobby_id )
{
CConnectedPlayer player = CConnectedPlayerManager.Instance.Get_Player_By_Persistence_ID( player_id );
player.On_Join_Lobby_Success( lobby_id );
CServerLobby lobby = Get_Lobby( lobby_id );
CLog.Log( ELoggingChannel.Lobby, ELogLevel.Medium, String.Format( "Player {0} successfully joined lobby {1}.",
player.Name,
lobby.GameDescription ) );
CJoinLobbySuccess join_response = new CJoinLobbySuccess( request_id, lobby.Clone_State() );
CServerMessageRouter.Send_Message_To_Player( join_response, player_id );
ELobbyMemberType member_type;
uint member_index;
lobby.Get_Member_Info( player_id, out member_index, out member_type );
CLobbyMemberJoinedOperation op = new CLobbyMemberJoinedOperation( player_id, player.Name, member_type, member_index );
Send_Message_To_Members( lobby_id, new CLobbyOperationMessage( op ), player_id );
}
public void On_Player_Disconnect( EPersistenceID player_id, ELobbyID lobby_id )
{
Change_Player_State( player_id, lobby_id, ELobbyMemberState.Disconnected );
}
public void Change_Player_State( EPersistenceID player_id, ELobbyID lobby_id, ELobbyMemberState new_state )
{
CServerLobby lobby = Get_Lobby( lobby_id );
if ( lobby == null )
{
return;
}
ELobbyMemberState old_state = lobby.Get_Member_State( player_id );
if ( old_state == new_state )
{
return;
}
CLog.Log( ELoggingChannel.Lobby, ELogLevel.Medium, String.Format( "Player {0} changed state in lobby {1} from {2} to {3}.",
CConnectedPlayerManager.Get_Player_Log_Name( player_id ),
Get_Lobby_Log_Description( lobby_id ),
old_state.ToString(),
new_state.ToString() ) );
lobby.Set_Member_State( player_id, new_state );
CLobbyMemberChangeStateOperation change_state_op = new CLobbyMemberChangeStateOperation( player_id, new_state );
Send_Message_To_Members( lobby_id, new CLobbyOperationMessage( change_state_op ) );
}
public void On_Player_Reconnect( EPersistenceID player_id, ELobbyID lobby_id )
{
CServerLobby lobby = Get_Lobby( lobby_id );
if ( lobby == null )
{
throw new CApplicationException( "Player reconnected to non-existent lobby." );
}
CLog.Log( ELoggingChannel.Lobby, ELogLevel.Medium, String.Format( "Player {0} successfully rejoined lobby {1}.",
CConnectedPlayerManager.Get_Player_Log_Name( player_id ),
Get_Lobby_Log_Description( lobby_id ) ) );
Change_Player_State( player_id, lobby_id, ELobbyMemberState.Not_Ready );
CServerMessageRouter.Send_Message_To_Player( new CJoinLobbySuccess( EMessageRequestID.Invalid, lobby.Clone_State() ), player_id );
if ( lobby.ChatChannel != EChannelID.Invalid )
{
CAsyncBackendOperations.Player_Join_Lobby_Channel( player_id, lobby_id, lobby.ChatChannel );
}
}
private void Send_Message_To_Members( ELobbyID lobby_id, CNetworkMessage message, EPersistenceID exclude_id )
{
CServerLobby lobby = Get_Lobby( lobby_id );
if ( lobby == null )
{
return;
}
lobby.ConnectedMemberIDs.Where( cid => cid != exclude_id ).Apply( id => CServerMessageRouter.Send_Message_To_Player( message, id ) );
}
public void Remove_From_Lobby( ELobbyID lobby_id, EPersistenceID player_id, ERemovedFromLobbyReason reason )
{
Remove_From_Lobby( lobby_id, player_id, reason, EMessageRequestID.Invalid );
}
// Private interface
// Callbacks
// Channel Creation
private static void On_Lobby_Chat_Channel_Creation_Response( ELobbyID lobby_id, EPersistenceID player_id, CCreateChatChannelResponseServerMessage response_msg )
{
CServerLobbyManager.Instance.On_Lobby_Chat_Channel_Creation_Response( lobby_id, player_id, response_msg );
}
public void Remove_From_Lobby( ELobbyID lobby_id, EPersistenceID player_id, ERemovedFromLobbyReason reason, EMessageRequestID request_id )
{
CServerLobby lobby = Get_Lobby( lobby_id );
if ( lobby == null )
{
return;
}
CLog.Log( ELoggingChannel.Lobby, ELogLevel.Medium, String.Format( "Removing player {0} from lobby {1} for reason {2}.",
CConnectedPlayerManager.Get_Player_Log_Name( player_id ),
Get_Lobby_Log_Description( lobby_id ),
reason.ToString() ) );
if ( CConnectedPlayerManager.Instance.Is_Connected( player_id ) && reason != ERemovedFromLobbyReason.Lobby_Destroyed_Game_Started )
{
CAsyncBackendOperations.Join_General_Channel( player_id, EMessageRequestID.Invalid );
}
CConnectedPlayer player = CConnectedPlayerManager.Instance.Get_Player_By_Persistence_ID( player_id );
player.On_Leave_Lobby();
CLobbyMemberLeftOperation op = new CLobbyMemberLeftOperation( player_id, reason );
bool is_lobby_shutdown = Is_Channel_Shutdown_Reason( reason );
if ( is_lobby_shutdown )
{
CServerMessageRouter.Send_Message_To_Player( new CLobbyOperationMessage( op ), player_id );
}
else
{
Send_Message_To_Members( lobby_id, new CLobbyOperationMessage( op ) );
}
lobby.Remove_Member( player_id, !is_lobby_shutdown );
}
public void Shutdown_Lobby( ELobbyID lobby_id, ELobbyDestroyedReason reason )
{
CLog.Log( ELoggingChannel.Lobby, ELogLevel.Medium, String.Format( "Shutting down lobby {0} for reason {1}.",
Get_Lobby_Log_Description( lobby_id ),
reason.ToString() ) );
CServerLobby lobby = Get_Lobby( lobby_id );
if ( lobby == null )
{
return;
}
if ( lobby.IsPublic )
{
CServerLobbyBrowserManager.Instance.Notify_Browsers_Of_Removed_Lobby( lobby_id );
}
List< EPersistenceID > members = new List< EPersistenceID >( lobby.MemberIDs );
members.Apply( member => Remove_From_Lobby( lobby.ID, member, Compute_Removal_Reason( reason ) ) );
if ( lobby.ChatChannel != EChannelID.Invalid )
{
CDestroyChatChannelServerMessage destroy_channel_message = new CDestroyChatChannelServerMessage( lobby.ChatChannel );
CServerMessageRouter.Send_Message_To_Chat_Server( destroy_channel_message );
}
m_Lobbies.Remove( lobby_id );
m_LobbiesByCreator.Remove( lobby.Creator );
}
private CServerLobbyManager()
{
m_NextLobbyID = ( ELobbyID ) ( ELobbyID.Invalid + 1 );
}
// constructors
public CServerLobby( ELobbyID id, CLobbyConfig config, EPersistenceID creator )
: base(id, config, creator)
{
}
public void Add_Watched_Lobby( ELobbyID lobby_id )
{
m_WatchedLobbies.Add( lobby_id );
}
