tanksdlg.cpp

分布式坦克游戏

    HideGameControl (m_ShieldStatus, FALSE);
    HideGameControl (m_AmmoStatus, FALSE);
    HideGameControl (m_BonusStatus, FALSE);

    m_GameState = GAME_ON;
}

void CTanksDlg::GameOver()
{
        // Can only be called from GAME_ON state
    ASSERT (GAME_ON == m_GameState);
        // Disable "stop game" menu item
    GetMenu()->EnableMenuItem(ID_STOP_GAME, MF_BYCOMMAND | MF_GRAYED);
    m_GameState = GAME_OVER;
        // Disable chat dialog. We can leave it open though, because our tank ID
        // is still occupied:
    GetMenu()->EnableMenuItem(ID_CHAT_OPEN, MF_BYCOMMAND | MF_GRAYED);

        // Add the GameOver animation object to the game:
    CMessage::MessageData DummyParams;
    TANKS_APP->m_gIncomingMsgQueue.Enqueue (CMessage::ADD_GAME_OVER, DummyParams);
}

void CTanksDlg::OnStopGame() 
// Called after the user pressed a key in the "Game-Over" animation sequence
{
        // Can only be called from GAME_OVER or GAME_ONstate
    ASSERT (GAME_OFF != m_GameState);
        // Warn host before we continue:
    if (TANKS_APP->m_gCommManager.IsHost()) {
        if (IDNO == AfxMessageBox(IDS_HOST_ON_STOP, MB_YESNO | MB_ICONQUESTION))
            return;
    }

        // Hide the controls
    HideGameControl (m_ShieldStatus, TRUE);
    HideGameControl (m_AmmoStatus, TRUE);
    HideGameControl (m_BonusStatus, TRUE);
    
        // Enable "new game" menu item
    GetMenu()->EnableMenuItem(ID_NEW_GAME, MF_BYCOMMAND | MF_ENABLED);
        // Disable "stop game" menu item
    GetMenu()->EnableMenuItem(ID_STOP_GAME, MF_BYCOMMAND | MF_GRAYED);
        // Disable "chat open" menu item
    m_ChatDlg.Close();
    GetMenu()->EnableMenuItem(ID_CHAT_OPEN, MF_BYCOMMAND | MF_GRAYED);

    m_GameState = GAME_OFF;

        // Stop player, and close session:
    TANKS_APP->m_gCommManager.OnStopGame();

    TANKS_APP->EndGameThreads();
        // Cause the logo screen to redraw
    m_Map.Invalidate (TRUE);
}



void CTanksDlg::OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct) 
{
    CDC *pdc = CDC::FromHandle (lpDrawItemStruct->hDC);

    switch (nIDCtl) {
        case IDC_MAP:   // Draw map region 
            { 
                if (m_GameState != GAME_OFF)
                {   // Let the renderer do its job
                    m_GameManager.RefreshDisplay ();
                }
                else 
                {
                    // Now paste the splash screen to the DC please........

                    CDIB dib;
                    if (dib.ReadFromResource (IDB_SPLASH))
                        dib.Paint (pdc);
                }
            }
            break;

        case IDC_SHIELD_STATUS:
            m_ShieldStatus.GetImage () -> Paint (pdc);
            break;

        case IDC_AMMO_STATUS:
            m_AmmoStatus.GetImage () -> Paint (pdc);
            break;

        case IDC_BONUS_STATUS:
            m_BonusStatus.GetImage () -> Paint (pdc);
            break;

        default:
            CDialog::OnDrawItem(nIDCtl, lpDrawItemStruct);
            break;
    }
}

void CTanksDlg::AlignControls()
{

    CRect ctlRect, dlgRect;

    GetWindowRect (dlgRect);
    GetClientRect (ctlRect);

    int iExtraRoom = dlgRect.Height() - ctlRect.Height() + 10;

    MoveWindow (dlgRect.left, dlgRect.top, 
                MAP_WIDTH + 20 + SHIELD_STATUS_WIDTH + AMMO_STATUS_WIDTH,
                MAP_HEIGHT + iExtraRoom);

    m_ShieldStatus.GetClientRect (ctlRect);
    m_ShieldStatus.MoveWindow ( ctlRect.left + 5,
                                ctlRect.top + 5, 
                                SHIELD_STATUS_WIDTH, 
                                MAP_HEIGHT,
                                FALSE);

    m_Map.GetClientRect (ctlRect);
    int iMapX = ctlRect.left + 10 + SHIELD_STATUS_WIDTH,
        iMapY = ctlRect.top + 5;

    m_Map.MoveWindow (iMapX, iMapY, MAP_WIDTH, MAP_HEIGHT, FALSE);

    m_AmmoStatus.GetClientRect (ctlRect);
    m_AmmoStatus.MoveWindow (   ctlRect.left + MAP_WIDTH + SHIELD_STATUS_WIDTH + 15, 
                                ctlRect.top + 5, 
                                AMMO_STATUS_WIDTH, 
                                AMMO_STATUS_HEIGHT,
                                FALSE);

    m_BonusStatus.GetClientRect (ctlRect);
    m_BonusStatus.MoveWindow (  ctlRect.left + MAP_WIDTH + SHIELD_STATUS_WIDTH + 15, 
                                ctlRect.top + AMMO_STATUS_HEIGHT + 5, 
                                AMMO_STATUS_WIDTH, 
                                MAP_HEIGHT - AMMO_STATUS_HEIGHT,
                                FALSE);
}

BOOL CTanksDlg::OnEraseBkgnd(CDC* pDC) 
{
    // Keep Windows from erasing the background of our map
    if (pDC == m_Map.GetDC())
        return TRUE;
    return CDialog::OnEraseBkgnd (pDC);
}

BOOL 
CTanksDlg::PreTranslateMessage(MSG* pMsg)
{
    if (GAME_OFF != m_GameState)
    {
        // Catch key strokes only if a game is active
        switch (pMsg->message) {
            case WM_KEYDOWN:
            case WM_SYSKEYDOWN:
                if (GAME_OVER == m_GameState)
                {
                    // Waiting for any key from the user, and one just arrived.
                    OnStopGame();
                    return TRUE;    // Don't let the dialog have this key
                }
                else 
                {
                    if (m_KbdManager.SetKey(pMsg->wParam) ||
                        (VK_ESCAPE == pMsg->wParam))
                            // Key was successfully mapped to game 
                            // or it was Esc
                        return TRUE;
                    else
                            // We don't know this key => dispatch it to the dialog
                        return FALSE;
                }
                break;
            case WM_KEYUP:
            case WM_SYSKEYUP:
                if (m_KbdManager.UnsetKey(pMsg->wParam) ||
                    (VK_ESCAPE == pMsg->wParam))
                        // Key was successfully mapped to game 
                        // or it was Esc
                    return TRUE;
                else
                        // We don't know this key => dispatch it to the dialog
                    return FALSE;
                break;
        }
    }
    return CDialog::PreTranslateMessage(pMsg);
}


void CTanksDlg::HideGameControl(CWnd &ctrl, BOOL bHide)
{
    ctrl.EnableWindow (bHide ? FALSE : TRUE);
    ctrl.ShowWindow (bHide ? SW_HIDE : SW_SHOW);
}

void CTanksDlg::OnClose() 
{
    // Catch application before exiting:
    if (IsGameOn()) {
        UINT uStrInd = TANKS_APP->m_gCommManager.IsHost() 
            ? IDS_HOST_ON_EXIT 
            : IDS_PLAYER_ON_EXIT;
        if (IDNO == AfxMessageBox(uStrInd, MB_YESNO | MB_ICONQUESTION))
            return;
    }   
    CDialog::OnClose();
}

void CTanksDlg::CreateStatusPanes()
{
    m_AmmoStatus.Create ();
    m_BonusStatus.Create ();

    m_ShieldStatus.SetLevel (0);
    m_AmmoStatus.SetShellsCount (0);
    m_AmmoStatus.SetBulletsCount (0);
    m_AmmoStatus.SetMinesCount (0);
    m_BonusStatus.SetAerialSupport (FALSE);
    m_BonusStatus.SetFastFireRate (FALSE);
}

void CTanksDlg::StartDIBDrawingEngine()
{
    TANKS_APP->m_gDrawDIB.Open ();
}

BOOL CTanksDlg::OnQueryNewPalette() 
{
    return TRUE;
}


void CTanksDlg::OnPaletteChanged(CWnd* pFocusWnd) 
{
    if (pFocusWnd != this)
        OnQueryNewPalette ();
}



void CTanksDlg::CheckDPlayVersion()
{
/*  In this function we should check that we can create a DPlay2 interface.
    If not - we should display a detailed dialog to the user, telling him
    that he cannot connect or host a session and point the user to the URL
    where he can download the latest SP (for NT) or DirectX runtime.
*/
}

void CTanksDlg::OnOK()
{
    // This function is here to override the default CDialog::OnOK which
    // closes the dialog window  - we don't want that to happen
}

void CTanksDlg::OnServerMgmt() 
{
    if (!(TANKS_APP->GetStoredIsHostFlag()))
        return; // Player is not hosting a game
    m_SrvMgmtDlg.Open (this);
}

void
CTanksDlg::OnChatOpen()
{
    if (m_GameState != GAME_ON)   // We have to have a local tank ID to send chat msg:
        return;
    m_ChatDlg.Open(this);
}

void CTanksDlg::OnPlayersGuide() 
{
    CString cstrHTML = TANKS_APP->m_pszHelpFilePath;
    int i=cstrHTML.ReverseFind ('\\');
    cstrHTML = cstrHTML.Left (i);
    cstrHTML += "\\HTML\\players.htm";
    
    HINSTANCE hRes = ShellExecute ( m_hWnd, 
                                    "open", 
                                    cstrHTML,
                                    NULL,
                                    NULL,
                                    SW_MAXIMIZE);
    if (DWORD(hRes) <= 32)
        AfxMessageBox (IDS_CANT_SHOW_IE, MB_OK);
}            

void 
CTanksDlg::OnSoundMute() 
{
    UINT uFlag = GetMenu()->GetMenuState(ID_SOUND_MUTE, MF_BYCOMMAND);
    if (MF_CHECKED == uFlag)
    {   // The user wants to uncheck (return the game sound):
        GetMenu()->CheckMenuItem(ID_SOUND_MUTE, MF_UNCHECKED);
        TANKS_APP->m_gSoundManager.SetMuteMode(FALSE);
        TANKS_APP->SetStoredMuteMode(FALSE);
    } else if (MF_UNCHECKED == uFlag)
    {   // The user wants to check (mute the game sound):
        GetMenu()->CheckMenuItem(ID_SOUND_MUTE, MF_CHECKED);
        TANKS_APP->m_gSoundManager.SetMuteMode(TRUE);
        TANKS_APP->SetStoredMuteMode(TRUE);
    }
}