// Player ops
public static void Join_General_Channel( EPersistenceID player_id, EMessageRequestID client_request_id )
{
ESessionID session_id = CConnectedPlayerManager.Instance.Get_Active_Player_Session_ID( player_id );
Change_System_Channel( player_id,
CConnectedPlayerManager.Instance.GeneralChatChannel,
EChannelGameProperties.OrdinarySingletonMask,
delegate( CResponseMessage response ) { On_Join_General_Channel_Response( response, session_id, client_request_id ); } );
}
// Construction
public CKickPlayerFromLobbyResponse( EMessageRequestID request_id, EKickPlayerFromLobbyError reason )
: base(request_id)
{
Reason = reason;
}
// Construction
public CIgnorePlayerResponse( EMessageRequestID request_id, EPersistenceID ignored_id, EIgnorePlayerResult result )
: base(request_id)
{
IgnoredID = ignored_id;
Result = result;
}
// Construction
public CContinueMatchResponse( EMessageRequestID request_id, EContinueMatchFailure error )
: base(request_id)
{
Error = error;
}
// Player Ops
private static void On_Chat_Server_Announce_Response( CResponseMessage response, ESessionID session_id, EMessageRequestID client_request_id )
{
if ( !CConnectedPlayerManager.Instance.Is_Connection_Valid( session_id ) )
{
return;
}
CAnnouncePlayerToChatServerResponse message = response as CAnnouncePlayerToChatServerResponse;
CAnnouncePlayerToChatServerRequest request = message.Request as CAnnouncePlayerToChatServerRequest;
CConnectedPlayer player = CConnectedPlayerManager.Instance.Get_Active_Player_By_Persistence_ID( request.PersistenceID );
if ( player != null )
{
CConnectedPlayerManager.Instance.On_Chat_Server_Announce_Response( player, message.Success, client_request_id );
}
}
// Construction
public CCreateChatChannelResponseServerMessage( EMessageRequestID request_id )
: base(request_id)
{
}
// Construction
public CLeaveMatchResponse( EMessageRequestID request_id, ELeaveMatchFailureError error )
: base(request_id)
{
Error = error;
}
private void On_Unignore_Persistence_Return( CPersistenceResponse response, EMessageRequestID request_id, EPersistenceID source_player )
{
CRemoveIgnoredPlayerPersistenceResponse unignore_response = response as CRemoveIgnoredPlayerPersistenceResponse;
if ( unignore_response.Error != EPersistenceError.None )
{
CServerMessageRouter.Send_Message_To_Player( new CUnignorePlayerResponse( request_id, EPersistenceID.Invalid, EUnignorePlayerResult.Persistence_Error ), source_player );
return;
}
if ( unignore_response.Result != EUnignorePlayerResult.Success )
{
CServerMessageRouter.Send_Message_To_Player( new CUnignorePlayerResponse( request_id, EPersistenceID.Invalid, unignore_response.Result ), source_player );
return;
}
CServerMessageRouter.Send_Message_To_Chat_Server( new CRemovePlayerFromChatIgnoreListServerMessage( source_player, unignore_response.IgnoredPlayerID ) );
CServerMessageRouter.Send_Message_To_Player( new CUnignorePlayerResponse( request_id, unignore_response.IgnoredPlayerID, EUnignorePlayerResult.Success ), source_player );
CServerLobby lobby = CServerLobbyManager.Instance.Get_Lobby_By_Creator( source_player );
if ( lobby != null && lobby.IsPublic )
{
CServerLobbyBrowserManager.Instance.Notify_Browser_Of_Lobby_Unban_Or_Unignore( unignore_response.IgnoredPlayerID, lobby.ID );
}
}
// Construction
public CQueryPlayerInfoResponse( EMessageRequestID request_id )
: base(request_id)
{
Infos = new List< CPlayerInfo >();
}
public void On_Chat_Server_Announce_Response( CConnectedPlayer player, bool success, EMessageRequestID hello_request_id )
{
ESessionID session_id = player.SessionID;
if ( success == false )
{
Send_Message( new CClientHelloResponse( hello_request_id, EConnectRefusalReason.Unable_To_Announce_To_Chat_Server ), session_id );
Add_Network_Operation( new CDisconnectRequestOperation( session_id, EDisconnectReason.Server_Request ) );
}
else
{
Join_Required_Channel_On_Connect( player.PersistenceID, hello_request_id );
}
}
private void Join_Required_Channel_On_Connect( EPersistenceID player_id, EMessageRequestID hello_request_id )
{
CConnectedPlayer player = Get_Player_By_Persistence_ID( player_id );
switch ( player.State )
{
case EConnectedPlayerState.Chat_Idle:
CAsyncBackendOperations.Join_General_Channel( player_id, hello_request_id );
break;
case EConnectedPlayerState.Lobby_Idle:
CServerMessageRouter.Send_Message_To_Session( new CClientHelloResponse( hello_request_id, CDatabaseProxy.Instance.Get_Player_Data( player_id ) ), player.SessionID );
player.Set_Connected();
CServerLobbyManager.Instance.On_Player_Reconnect( player_id, player.LobbyID );
break;
case EConnectedPlayerState.Game_Idle:
CServerMessageRouter.Send_Message_To_Session( new CClientHelloResponse( hello_request_id, CDatabaseProxy.Instance.Get_Player_Data( player_id ) ), player.SessionID );
player.Set_Connected();
CServerMatchInstanceManager.Instance.On_Player_Reconnect( player_id, player.MatchID );
break;
case EConnectedPlayerState.Lobby_Browsing:
case EConnectedPlayerState.Lobby_Matching:
throw new CApplicationException( "Player in an impossible state on reconnection" );
}
}
// Construction
public CLobbyStartMatchResponse( EMessageRequestID request_id, EStartMatchError error )
: base(request_id)
{
Error = error;
}
// Construction
public CLobbyChangeGameCountResponse( EMessageRequestID request_id, ELobbyChangeGameCountError error )
: base(request_id)
{
Error = error;
}
// Construction
public CLeaveLobbyResponse( EMessageRequestID request_id, ELeaveLobbyFailureReason reason )
: base(request_id)
{
Reason = reason;
}
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 );
}
// Construction
public CClientHelloResponse( EMessageRequestID request_id, CPersistentPlayerData player_data )
: base(request_id)
{
PlayerData = player_data.Clone();
Reason = EConnectRefusalReason.None;
}
// Construction
public CAnnouncePlayerToChatServerResponse( EMessageRequestID request_id, bool success )
: base(request_id)
{
Success = success;
}
public CClientHelloResponse( EMessageRequestID request_id, EConnectRefusalReason reason )
: base(request_id)
{
Reason = reason;
}
// Construction
public CJoinChatChannelResponseServerMessage( EMessageRequestID request_id, EChannelJoinError error )
: base(request_id)
{
Error = error;
}
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 );
}
// Construction
public CMatchTakeTurnResponse( EMessageRequestID request_id, EGameActionFailure error )
: base(request_id)
{
Error = error;
}
private void Join_Lobby_Aux( EPersistenceID player_id, CServerLobby lobby, EMessageRequestID request_id, string password )
{
CConnectedPlayer player = CConnectedPlayerManager.Instance.Get_Active_Player_By_Persistence_ID( player_id );
if ( player == null )
{
throw new CApplicationException( "Processing a join request by an inactive player" );
}
if ( !player.State_Allows_Operation( EConnectedPlayerOperation.Join_Lobby ) )
{
On_Join_Lobby_Failure( ELobbyID.Invalid, player_id, request_id, EJoinLobbyFailureReason.Invalid_State_To_Join );
return;
}
EJoinLobbyFailureReason join_check_result = lobby.Check_Join( player_id );
if ( join_check_result != EJoinLobbyFailureReason.None )
{
On_Join_Lobby_Failure( lobby.ID, player_id, request_id, join_check_result );
return;
}
CServerLobbyBrowserManager.Instance.Stop_Browsing( player_id );
lobby.Add_Member( player_id );
On_Join_Lobby_Success( player_id, request_id, lobby.ID );
if ( lobby.ChatChannel != EChannelID.Invalid )
{
CAsyncBackendOperations.Player_Join_Lobby_Channel( player.PersistenceID, lobby.ID, lobby.ChatChannel );
}
}
public static void New_Player_Announce_To_Chat( CConnectedPlayer player, CPersistentPlayerData player_data, EMessageRequestID client_request_id )
{
ESessionID session_id = player.SessionID;
CAnnouncePlayerToChatServerRequest announce_request = new CAnnouncePlayerToChatServerRequest( session_id, player.PersistenceID, player.Name, player_data.IgnoreList );
announce_request.Handler = delegate( CResponseMessage response ) { On_Chat_Server_Announce_Response( response, session_id, client_request_id ); };
CServerMessageRouter.Send_Message_To_Chat_Server( announce_request );
}
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 static void On_Join_General_Channel_Response( CResponseMessage response, ESessionID session_id, EMessageRequestID client_request_id )
{
if ( !CConnectedPlayerManager.Instance.Is_Connection_Valid( session_id ) )
{
return;
}
CJoinChatChannelResponseServerMessage message = response as CJoinChatChannelResponseServerMessage;
CJoinChatChannelRequestServerMessage request = message.Request as CJoinChatChannelRequestServerMessage;
EPersistenceID player_id = request.PlayerID;
CConnectedPlayer player = CConnectedPlayerManager.Instance.Get_Active_Player_By_Persistence_ID( player_id );
if ( player != null )
{
player.On_Join_General_Channel_Response( message.Error, client_request_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 );
}
}
// Construction
public CStartBrowseLobbyResponse( EMessageRequestID request_id, EStartBrowseResult result )
: base(request_id)
{
Result = result;
LobbySummaries = new List< CLobbySummary >();
}
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 );
}
// Construction
public CPlayerTellResponse( EMessageRequestID request_id )
: base(request_id)
{
}
// Construction
public CJoinLobbySuccess( EMessageRequestID request_id, CLobbyState lobby_state )
: base(request_id)
{
LobbyState = lobby_state;
}
