//---------------------------------------------------------------------------- // File: ChatPeer.cpp // // Desc: The main game file for the ChatPeer sample. It connects // players together with two dialog boxes to prompt users on the // connection settings to join or create a session. After the user // connects to a sesssion, the sample displays a multiplayer stage. // // After a new game has started the sample begins a very simplistic // chat session where users can send text to each other. // // Copyright (c) 1999-2001 Microsoft Corp. All rights reserved. //----------------------------------------------------------------------------- #define STRICT #include #include #include #include #include #include #include "NetConnect.h" #include "DXUtil.h" #include "resource.h" //----------------------------------------------------------------------------- // Player context locking defines //----------------------------------------------------------------------------- CRITICAL_SECTION g_csPlayerContext; #define PLAYER_LOCK() EnterCriticalSection( &g_csPlayerContext ); #define PLAYER_ADDREF( pPlayerInfo ) if( pPlayerInfo ) pPlayerInfo->lRefCount++; #define PLAYER_RELEASE( pPlayerInfo ) if( pPlayerInfo ) { pPlayerInfo->lRefCount--; if( pPlayerInfo->lRefCount <= 0 ) SAFE_DELETE( pPlayerInfo ); } pPlayerInfo = NULL; #define PLAYER_UNLOCK() LeaveCriticalSection( &g_csPlayerContext ); //----------------------------------------------------------------------------- // Defines, and constants //----------------------------------------------------------------------------- #define DPLAY_SAMPLE_KEY TEXT("Software\\Microsoft\\DirectX DirectPlay Samples") #define MAX_PLAYER_NAME 14 #define MAX_CHAT_STRINGS 50 #define MAX_CHAT_STRING_LENGTH 508 #define WM_APP_UPDATE_STATS (WM_APP + 0) #define WM_APP_CHAT (WM_APP + 1) // This GUID allows DirectPlay to find other instances of the same game on // the network. So it must be unique for every game, and the same for // every instance of that game. // {876A3036-FFD7-46bc-9209-B42F617B9BE7} GUID g_guidApp = { 0x876a3036, 0xffd7, 0x46bc, { 0x92, 0x9, 0xb4, 0x2f, 0x61, 0x7b, 0x9b, 0xe7 } }; struct APP_PLAYER_INFO { LONG lRefCount; // Ref count so we can cleanup when all threads // are done w/ this object DPNID dpnidPlayer; // DPNID of player TCHAR strPlayerName[MAX_PLAYER_NAME]; // Player name }; //----------------------------------------------------------------------------- // Global variables //----------------------------------------------------------------------------- IDirectPlay8Peer* g_pDP = NULL; // DirectPlay peer object CNetConnectWizard* g_pNetConnectWizard = NULL; // Connection wizard IDirectPlay8LobbiedApplication* g_pLobbiedApp = NULL; // DirectPlay lobbied app BOOL g_bWasLobbyLaunched = FALSE; // TRUE if lobby launched HINSTANCE g_hInst = NULL; // HINST of app HWND g_hDlg = NULL; // HWND of main dialog DPNID g_dpnidLocalPlayer = 0; // DPNID of local player LONG g_lNumberOfActivePlayers = 0; // Number of players currently in game TCHAR g_strAppName[256] = TEXT("ChatPeer"); HRESULT g_hrDialog; // Exit code for app TCHAR g_strLocalPlayerName[MAX_PATH]; // Local player name TCHAR g_strSessionName[MAX_PATH]; // Session name TCHAR g_strPreferredProvider[MAX_PATH]; // Provider string //----------------------------------------------------------------------------- // App specific DirectPlay messages and structures //----------------------------------------------------------------------------- #define GAME_MSGID_CHAT 1 // Change compiler pack alignment to be BYTE aligned, and pop the current value #pragma pack( push, 1 ) struct GAMEMSG_GENERIC { BYTE nType; }; struct GAMEMSG_CHAT : public GAMEMSG_GENERIC { TCHAR strChatString[MAX_CHAT_STRING_LENGTH]; }; // Pop the old pack alignment #pragma pack( pop ) struct APP_QUEUED_DATA { GAMEMSG_CHAT* pChatMsg; DPNHANDLE hBufferHandle; }; //----------------------------------------------------------------------------- // Function-prototypes //----------------------------------------------------------------------------- HRESULT WINAPI DirectPlayMessageHandler( PVOID pvUserContext, DWORD dwMessageId, PVOID pMsgBuffer ); HRESULT WINAPI DirectPlayLobbyMessageHandler( PVOID pvUserContext, DWORD dwMessageId, PVOID pMsgBuffer ); INT_PTR CALLBACK ChatDlgProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam ); HRESULT InitDirectPlay(); HRESULT OnInitDialog( HWND hDlg ); HRESULT SendChatMessage( HWND hDlg ); //----------------------------------------------------------------------------- // Name: WinMain() // Desc: Entry point for the application. Since we use a simple dialog for // user interaction we don't need to pump messages. //----------------------------------------------------------------------------- INT APIENTRY WinMain( HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR pCmdLine, INT nCmdShow ) { HRESULT hr; HKEY hDPlaySampleRegKey; BOOL bConnectSuccess = FALSE; g_hInst = hInst; InitializeCriticalSection( &g_csPlayerContext ); // Read persistent state information from registry RegCreateKeyEx( HKEY_CURRENT_USER, DPLAY_SAMPLE_KEY, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hDPlaySampleRegKey, NULL ); DXUtil_ReadStringRegKey( hDPlaySampleRegKey, TEXT("Player Name"), g_strLocalPlayerName, MAX_PATH, TEXT("TestPlayer") ); DXUtil_ReadStringRegKey( hDPlaySampleRegKey, TEXT("Session Name"), g_strSessionName, MAX_PATH, TEXT("TestGame") ); DXUtil_ReadStringRegKey( hDPlaySampleRegKey, TEXT("Preferred Provider"), g_strPreferredProvider, MAX_PATH, TEXT("DirectPlay8 TCP/IP Service Provider") ); // Init COM so we can use CoCreateInstance CoInitializeEx( NULL, COINIT_MULTITHREADED ); // Create helper class g_pNetConnectWizard = new CNetConnectWizard( hInst, NULL, g_strAppName, &g_guidApp ); if( FAILED( hr = InitDirectPlay() ) ) { DXTRACE_ERR( TEXT("InitDirectPlay"), hr ); MessageBox( NULL, TEXT("Failed initializing IDirectPlay8Peer. ") TEXT("The sample will now quit."), TEXT("DirectPlay Sample"), MB_OK | MB_ICONERROR ); goto LCleanup; } // Check if we were launched from a lobby client if( g_bWasLobbyLaunched && g_pNetConnectWizard->HaveConnectionSettingsFromLobby() ) { // If were lobby launched then DPL_MSGID_CONNECT has already been // handled, so we can just tell the wizard to connect to the lobby // that has sent us a DPL_MSGID_CONNECT msg. if( FAILED( hr = g_pNetConnectWizard->ConnectUsingLobbySettings() ) ) { DXTRACE_ERR( TEXT("ConnectUsingLobbySettings"), hr ); MessageBox( NULL, TEXT("Failed to connect using lobby settings. ") TEXT("The sample will now quit."), TEXT("DirectPlay Sample"), MB_OK | MB_ICONERROR ); bConnectSuccess = FALSE; } else { // Read information from g_pNetConnectWizard _tcscpy( g_strLocalPlayerName, g_pNetConnectWizard->GetPlayerName() ); bConnectSuccess = TRUE; } } else { // If not lobby launched, prompt the user about the network // connection and which session they would like to join or // if they want to create a new one. // Setup connection wizard g_pNetConnectWizard->SetPlayerName( g_strLocalPlayerName ); g_pNetConnectWizard->SetSessionName( g_strSessionName ); g_pNetConnectWizard->SetPreferredProvider( g_strPreferredProvider ); // Do the connection wizard hr = g_pNetConnectWizard->DoConnectWizard( FALSE ); if( FAILED( hr ) ) { DXTRACE_ERR( TEXT("DoConnectWizard"), hr ); MessageBox( NULL, TEXT("Multiplayer connect failed. ") TEXT("The sample will now quit."), TEXT("DirectPlay Sample"), MB_OK | MB_ICONERROR ); bConnectSuccess = FALSE; } else if( hr == NCW_S_QUIT ) { // The user canceled the Multiplayer connect, so quit bConnectSuccess = FALSE; } else { bConnectSuccess = TRUE; // Read information from g_pNetConnectWizard _tcscpy( g_strLocalPlayerName, g_pNetConnectWizard->GetPlayerName() ); _tcscpy( g_strSessionName, g_pNetConnectWizard->GetSessionName() ); _tcscpy( g_strPreferredProvider, g_pNetConnectWizard->GetPreferredProvider() ); // Write information to the registry DXUtil_WriteStringRegKey( hDPlaySampleRegKey, TEXT("Player Name"), g_strLocalPlayerName ); DXUtil_WriteStringRegKey( hDPlaySampleRegKey, TEXT("Session Name"), g_strSessionName ); DXUtil_WriteStringRegKey( hDPlaySampleRegKey, TEXT("Preferred Provider"), g_strPreferredProvider ); } } if( bConnectSuccess ) { // App is now connected via DirectPlay, so start the game. // For this sample, we just start a simple dialog box game. g_hrDialog = S_OK; DialogBox( hInst, MAKEINTRESOURCE(IDD_MAIN_GAME), NULL, (DLGPROC) ChatDlgProc ); if( FAILED( g_hrDialog ) ) { if( g_hrDialog == DPNERR_CONNECTIONLOST ) { MessageBox( NULL, TEXT("The DirectPlay session was lost. ") TEXT("The sample will now quit."), TEXT("DirectPlay Sample"), MB_OK | MB_ICONERROR ); } else { DXTRACE_ERR( TEXT("DialogBox"), g_hrDialog ); MessageBox( NULL, TEXT("An error occured during the game. ") TEXT("The sample will now quit."), TEXT("DirectPlay Sample"), MB_OK | MB_ICONERROR ); } } } LCleanup: // Cleanup DirectPlay and helper classes g_pNetConnectWizard->Shutdown(); if( g_pDP ) { g_pDP->Close(0); SAFE_RELEASE( g_pDP ); } if( g_pLobbiedApp ) { g_pLobbiedApp->Close( 0 ); SAFE_RELEASE( g_pLobbiedApp ); } // Don't delete the wizard until we know that // DirectPlay is out of its message handlers. // This will be true after Close() has been called. SAFE_DELETE( g_pNetConnectWizard ); RegCloseKey( hDPlaySampleRegKey ); DeleteCriticalSection( &g_csPlayerContext ); CoUninitialize(); return TRUE; } //----------------------------------------------------------------------------- // Name: InitDirectPlay() // Desc: //----------------------------------------------------------------------------- HRESULT InitDirectPlay() { DPNHANDLE hLobbyLaunchedConnection = NULL; HRESULT hr; // Create IDirectPlay8Peer if( FAILED( hr = CoCreateInstance( CLSID_DirectPlay8Peer, NULL, CLSCTX_INPROC_SERVER, IID_IDirectPlay8Peer, (LPVOID*) &g_pDP ) ) ) return DXTRACE_ERR( TEXT("CoCreateInstance"), hr ); // Create IDirectPlay8LobbiedApplication if( FAILED( hr = CoCreateInstance( CLSID_DirectPlay8LobbiedApplication, NULL, CLSCTX_INPROC_SERVER, IID_IDirectPlay8LobbiedApplication, (LPVOID*) &g_pLobbiedApp ) ) ) return DXTRACE_ERR( TEXT("CoCreateInstance"), hr ); // Init the helper class, now that g_pDP and g_pLobbiedApp are valid g_pNetConnectWizard->Init( g_pDP, g_pLobbiedApp ); // Init IDirectPlay8Peer if( FAILED( hr = g_pDP->Initialize( NULL, DirectPlayMessageHandler, 0 ) ) ) return DXTRACE_ERR( TEXT("Initialize"), hr ); // Init IDirectPlay8LobbiedApplication. Before this Initialize() returns // a DPL_MSGID_CONNECT msg may come in to the DirectPlayLobbyMessageHandler // so be prepared ahead of time. if( FAILED( hr = g_pLobbiedApp->Initialize( NULL, DirectPlayLobbyMessageHandler, &hLobbyLaunchedConnection, 0 ) ) ) return DXTRACE_ERR( TEXT("Initialize"), hr ); // IDirectPlay8LobbiedApplication::Initialize returns a handle to a connnection // if we have been lobby launced. Initialize is guanteeded to return after // the DPL_MSGID_CONNECT msg has been processed. So unless a we are expected // multiple lobby connections, we do not need to remember the lobby connection // handle since it will be recorded upon the DPL_MSGID_CONNECT msg. g_bWasLobbyLaunched = ( hLobbyLaunchedConnection != NULL ); return S_OK; } //----------------------------------------------------------------------------- // Name: ChatDlgProc() // Desc: Handles dialog messages //----------------------------------------------------------------------------- INT_PTR CALLBACK ChatDlgProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam ) { switch( msg ) { case WM_INITDIALOG: { g_hDlg = hDlg; if( FAILED( g_hrDialog = OnInitDialog( hDlg ) ) ) { DXTRACE_ERR( TEXT("OnInitDialog"), g_hrDialog ); EndDialog( hDlg, 0 ); } break; } case WM_APP_UPDATE_STATS: { // Update the number of players in the game TCHAR strNumberPlayers[32]; wsprintf( strNumberPlayers, TEXT("%d"), g_lNumberOfActivePlayers ); SetDlgItemText( hDlg, IDC_NUM_PLAYERS, strNumberPlayers ); break; } case WM_APP_CHAT: { HRESULT hr; DPNID dpnidPlayer = (DPNID) wParam; APP_PLAYER_INFO* pPlayerInfo = NULL; PLAYER_LOCK(); // enter player context CS // Get the player context accosicated with this DPNID hr = g_pDP->GetPlayerContext( dpnidPlayer, (LPVOID* const) &pPlayerInfo, 0); PLAYER_ADDREF( pPlayerInfo ); // addref player, since we are using it now PLAYER_UNLOCK(); // leave player context CS APP_QUEUED_DATA* pQueuedData = (APP_QUEUED_DATA*) lParam; if( FAILED(hr) || pPlayerInfo == NULL ) { // The player who sent this may have gone away before this // message was handled, so just ignore it if( pQueuedData ) { g_pDP->ReturnBuffer( pQueuedData->hBufferHandle,0 ); SAFE_DELETE( pQueuedData ); } break; } // Add the message to the local listbox HWND hWndChatBox = GetDlgItem( hDlg, IDC_CHAT_LISTBOX ); int nCount = (int)SendMessage( hWndChatBox, LB_GETCOUNT, 0, 0 ); if( nCount > MAX_CHAT_STRINGS ) SendMessage( hWndChatBox, LB_DELETESTRING, 0, 0 ); // Make the chat string from the player's name and the edit box string TCHAR strChatBuffer[MAX_PLAYER_NAME + MAX_CHAT_STRING_LENGTH + 32]; wsprintf( strChatBuffer, TEXT("<%s> %s"), pPlayerInfo->strPlayerName, pQueuedData->pChatMsg->strChatString ); PLAYER_LOCK(); // enter player context CS PLAYER_RELEASE( pPlayerInfo ); // Release player and cleanup if needed PLAYER_UNLOCK(); // leave player context CS // Add it, and make sure it is visible int nIndex = (int)SendMessage( hWndChatBox, LB_ADDSTRING, 0, (LPARAM)strChatBuffer ); SendMessage( hWndChatBox, LB_SETTOPINDEX, nIndex, 0 ); // Done with the buffer, so return it DirectPlay, // so that the memory can be reused g_pDP->ReturnBuffer( pQueuedData->hBufferHandle,0 ); SAFE_DELETE( pQueuedData ); break; } case WM_COMMAND: switch( LOWORD(wParam) ) { case IDC_CHAT_EDIT: if( HIWORD(wParam) == EN_UPDATE ) { BOOL bEnableSend; if( 0 == GetWindowTextLength( GetDlgItem( hDlg, IDC_CHAT_EDIT ) ) ) bEnableSend = FALSE; else bEnableSend = TRUE; EnableWindow( GetDlgItem( hDlg, IDC_SEND ), bEnableSend ); } break; case IDC_SEND: // The enter key was pressed, so send out the chat message if( FAILED( g_hrDialog = SendChatMessage( hDlg ) ) ) { DXTRACE_ERR( TEXT("SendChatMessage"), g_hrDialog ); EndDialog( hDlg, 0 ); } break; case IDCANCEL: g_hrDialog = S_OK; EndDialog( hDlg, 0 ); return TRUE; } break; } return FALSE; // Didn't handle message } //----------------------------------------------------------------------------- // Name: OnInitDialog() // Desc: Inits the dialog for the chat client. //----------------------------------------------------------------------------- HRESULT OnInitDialog( HWND hDlg ) { // Load and set the icon HICON hIcon = LoadIcon( g_hInst, MAKEINTRESOURCE( IDI_MAIN ) ); SendMessage( hDlg, WM_SETICON, ICON_BIG, (LPARAM) hIcon ); // Set big icon SendMessage( hDlg, WM_SETICON, ICON_SMALL, (LPARAM) hIcon ); // Set small icon // Display local player's name SetDlgItemText( hDlg, IDC_PLAYER_NAME, g_strLocalPlayerName ); PostMessage( hDlg, WM_APP_UPDATE_STATS, 0, 0 ); SetFocus( GetDlgItem( hDlg, IDC_CHAT_EDIT ) ); SendMessage( GetDlgItem( hDlg, IDC_CHAT_EDIT ), EM_SETEVENTMASK, 0, ENM_UPDATE ); EnableWindow( GetDlgItem( hDlg, IDC_SEND ), FALSE ); if( g_pNetConnectWizard->IsHostPlayer() ) SetWindowText( hDlg, TEXT("ChatPeer (Host)") ); else SetWindowText( hDlg, TEXT("ChatPeer") ); return S_OK; } //----------------------------------------------------------------------------- // Name: DirectPlayMessageHandler // Desc: Handler for DirectPlay messages. This function is called by // the DirectPlay message handler pool of threads, so be care of thread // synchronization problems with shared memory //----------------------------------------------------------------------------- HRESULT WINAPI DirectPlayMessageHandler( PVOID pvUserContext, DWORD dwMessageId, PVOID pMsgBuffer ) { // Try not to stay in this message handler for too long, otherwise // there will be a backlog of data. The best solution is to // queue data as it comes in, and then handle it on other threads // as this sample shows // This function is called by the DirectPlay message handler pool of // threads, so be care of thread synchronization problems with shared memory HRESULT hReturn = S_OK; switch( dwMessageId ) { case DPN_MSGID_CREATE_PLAYER: { HRESULT hr; PDPNMSG_CREATE_PLAYER pCreatePlayerMsg; pCreatePlayerMsg = (PDPNMSG_CREATE_PLAYER)pMsgBuffer; // Create a new and fill in a APP_PLAYER_INFO APP_PLAYER_INFO* pPlayerInfo = new APP_PLAYER_INFO; ZeroMemory( pPlayerInfo, sizeof(APP_PLAYER_INFO) ); pPlayerInfo->dpnidPlayer = pCreatePlayerMsg->dpnidPlayer; pPlayerInfo->lRefCount = 1; // Get the peer info and extract its name DWORD dwSize = 0; DPN_PLAYER_INFO* pdpPlayerInfo = NULL; hr = DPNERR_CONNECTING; // GetPeerInfo might return DPNERR_CONNECTING when connecting, // so just keep calling it if it does while( hr == DPNERR_CONNECTING ) hr = g_pDP->GetPeerInfo( pCreatePlayerMsg->dpnidPlayer, pdpPlayerInfo, &dwSize, 0 ); if( hr == DPNERR_BUFFERTOOSMALL ) { pdpPlayerInfo = (DPN_PLAYER_INFO*) new BYTE[ dwSize ]; ZeroMemory( pdpPlayerInfo, dwSize ); pdpPlayerInfo->dwSize = sizeof(DPN_PLAYER_INFO); hr = g_pDP->GetPeerInfo( pCreatePlayerMsg->dpnidPlayer, pdpPlayerInfo, &dwSize, 0 ); if( SUCCEEDED(hr) ) { // This stores a extra TCHAR copy of the player name for // easier access. This will be redundent copy since DPlay // also keeps a copy of the player name in GetPeerInfo() DXUtil_ConvertWideStringToGeneric( pPlayerInfo->strPlayerName, pdpPlayerInfo->pwszName, MAX_PLAYER_NAME ); if( pdpPlayerInfo->dwPlayerFlags & DPNPLAYER_LOCAL ) g_dpnidLocalPlayer = pCreatePlayerMsg->dpnidPlayer; } SAFE_DELETE_ARRAY( pdpPlayerInfo ); } // Tell DirectPlay to store this pPlayerInfo // pointer in the pvPlayerContext. pCreatePlayerMsg->pvPlayerContext = pPlayerInfo; // Update the number of active players, and // post a message to the dialog thread to update the // UI. This keeps the DirectPlay message handler // from blocking InterlockedIncrement( &g_lNumberOfActivePlayers ); if( g_hDlg != NULL ) PostMessage( g_hDlg, WM_APP_UPDATE_STATS, 0, 0 ); break; } case DPN_MSGID_DESTROY_PLAYER: { PDPNMSG_DESTROY_PLAYER pDestroyPlayerMsg; pDestroyPlayerMsg = (PDPNMSG_DESTROY_PLAYER)pMsgBuffer; APP_PLAYER_INFO* pPlayerInfo = (APP_PLAYER_INFO*) pDestroyPlayerMsg->pvPlayerContext; PLAYER_LOCK(); // enter player context CS PLAYER_RELEASE( pPlayerInfo ); // Release player and cleanup if needed PLAYER_UNLOCK(); // leave player context CS // Update the number of active players, and // post a message to the dialog thread to update the // UI. This keeps the DirectPlay message handler // from blocking InterlockedDecrement( &g_lNumberOfActivePlayers ); if( g_hDlg != NULL ) PostMessage( g_hDlg, WM_APP_UPDATE_STATS, 0, 0 ); break; } case DPN_MSGID_HOST_MIGRATE: { PDPNMSG_HOST_MIGRATE pHostMigrateMsg; pHostMigrateMsg = (PDPNMSG_HOST_MIGRATE)pMsgBuffer; if( pHostMigrateMsg->dpnidNewHost == g_dpnidLocalPlayer ) SetWindowText( g_hDlg, TEXT("ChatPeer (Host)") ); break; } case DPN_MSGID_TERMINATE_SESSION: { PDPNMSG_TERMINATE_SESSION pTerminateSessionMsg; pTerminateSessionMsg = (PDPNMSG_TERMINATE_SESSION)pMsgBuffer; g_hrDialog = DPNERR_CONNECTIONLOST; EndDialog( g_hDlg, 0 ); break; } case DPN_MSGID_RECEIVE: { PDPNMSG_RECEIVE pReceiveMsg; pReceiveMsg = (PDPNMSG_RECEIVE)pMsgBuffer; APP_PLAYER_INFO* pPlayerInfo = (APP_PLAYER_INFO*) pReceiveMsg->pvPlayerContext; if( NULL == pPlayerInfo ) break; GAMEMSG_GENERIC* pMsg = (GAMEMSG_GENERIC*) pReceiveMsg->pReceiveData; if( pMsg->nType == GAME_MSGID_CHAT ) { // This message is sent when a player has send a chat message to us, so // post a message to the dialog thread to update the UI. // This keeps the DirectPlay threads from blocking, and also // serializes the recieves since DirectPlayMessageHandler can // be called simultaneously from a pool of DirectPlay threads. GAMEMSG_CHAT* pChatMessage = (GAMEMSG_CHAT*) pMsg; // Record the buffer handle so the buffer can be returned later APP_QUEUED_DATA* pQueuedData = new APP_QUEUED_DATA; pQueuedData->hBufferHandle = pReceiveMsg->hBufferHandle; pQueuedData->pChatMsg = pChatMessage; // Pass the APP_QUEUED_DATA to the main dialog thread, so it can // process it. It will also cleanup the struct PostMessage( g_hDlg, WM_APP_CHAT, pPlayerInfo->dpnidPlayer, (LPARAM) pQueuedData ); // Tell DirectPlay to assume that ownership of the buffer // has been transferred to the application, and so it will // neither free nor modify it until ownership is returned // to DirectPlay through the ReturnBuffer() call. hReturn = DPNSUCCESS_PENDING; } break; } } // Make sure the DirectPlay MessageHandler calls the CNetConnectWizard handler, // so it can be informed of messages such as DPN_MSGID_ENUM_HOSTS_RESPONSE. if( hReturn != DPNSUCCESS_PENDING && SUCCEEDED(hReturn) && g_pNetConnectWizard ) hReturn = g_pNetConnectWizard->MessageHandler( pvUserContext, dwMessageId, pMsgBuffer ); return hReturn; } //----------------------------------------------------------------------------- // Name: DirectPlayLobbyMessageHandler // Desc: Handler for DirectPlay lobby messages. This function is called by // the DirectPlay lobby message handler pool of threads, so be careful of // thread synchronization problems with shared memory //----------------------------------------------------------------------------- HRESULT WINAPI DirectPlayLobbyMessageHandler( PVOID pvUserContext, DWORD dwMessageId, PVOID pMsgBuffer ) { switch( dwMessageId ) { case DPL_MSGID_CONNECT: { PDPL_MESSAGE_CONNECT pConnectMsg; pConnectMsg = (PDPL_MESSAGE_CONNECT)pMsgBuffer; // The CNetConnectWizard will handle this message for us, // so there is nothing we need to do here for this simple // sample. break; } case DPL_MSGID_DISCONNECT: { PDPL_MESSAGE_DISCONNECT pDisconnectMsg; pDisconnectMsg = (PDPL_MESSAGE_DISCONNECT)pMsgBuffer; // We should free any data associated with the lobby // client here, but there is none. break; } case DPL_MSGID_RECEIVE: { PDPL_MESSAGE_RECEIVE pReceiveMsg; pReceiveMsg = (PDPL_MESSAGE_RECEIVE)pMsgBuffer; // The lobby client sent us data. This sample doesn't // expected data from the client, but it is useful // for more complex apps. break; } case DPL_MSGID_CONNECTION_SETTINGS: { PDPL_MESSAGE_CONNECTION_SETTINGS pConnectionStatusMsg; pConnectionStatusMsg = (PDPL_MESSAGE_CONNECTION_SETTINGS)pMsgBuffer; // The lobby client has changed the connection settings. // This simple sample doesn't handle this, but more complex apps may // want to. break; } } // Make sure the DirectPlay MessageHandler calls the CNetConnectWizard handler, // so the wizard can be informed of lobby messages such as DPL_MSGID_CONNECT if( g_pNetConnectWizard ) return g_pNetConnectWizard->LobbyMessageHandler( pvUserContext, dwMessageId, pMsgBuffer ); return S_OK; } //----------------------------------------------------------------------------- // Name: SendChatMessage() // Desc: Create chat string based on the editbox and send it to everyone //----------------------------------------------------------------------------- HRESULT SendChatMessage( HWND hDlg ) { // Get length of item text DWORD dwEditboxBufferSize = (DWORD)SendDlgItemMessage( hDlg, IDC_CHAT_EDIT, WM_GETTEXTLENGTH, 0, 0 ); if( dwEditboxBufferSize == 0 ) return S_OK; // Don't do anything for blank messages GAMEMSG_CHAT msgChat; msgChat.nType = GAME_MSGID_CHAT; GetDlgItemText( hDlg, IDC_CHAT_EDIT, msgChat.strChatString, MAX_CHAT_STRING_LENGTH ); // Set the dwBufferSize to only send the string that has valid text in it. // Otherwise bandwidth is wasted. DPN_BUFFER_DESC bufferDesc; bufferDesc.dwBufferSize = sizeof(msgChat.nType) + (_tcslen(msgChat.strChatString)+1)*sizeof(TCHAR); bufferDesc.pBufferData = (BYTE*) &msgChat; // Send it to all of the players include the local client // DirectPlay will tell via the message handler // if there are any severe errors, so ignore any errors DPNHANDLE hAsync; g_pDP->SendTo( DPNID_ALL_PLAYERS_GROUP, &bufferDesc, 1, 0, NULL, &hAsync, DPNSEND_GUARANTEED ); // Blank out edit box SetDlgItemText( hDlg, IDC_CHAT_EDIT, TEXT("") ); return S_OK; }